字符串操作类
在Java中最常用的字符串操作类有三个：
1- String：在开发中最常用的字符串操作类，此类的对象我们一般叫做字符串对象，简称字符串。
2- StringBuffer：字符串缓冲区类，解决了String存在的问题，而且是线程安全的，所以在多线程环境下对于复杂字符串的叠加操作，我们一般使用此类。
3- StringBuilder：解决了String存在的问题，但是是线程不安全的，所以在单线程的环境下对于复杂字符串的叠加操作，我们一般使用此类。
这三个字符串操作类都是实现了CharSequence接口的，所以三个类的操作方法几乎是相同的。我们也经常说CharSequence是字符串操作的最高的父接口。
CharSequence中常用的操作方法如下：
char charAt(int index) : 返回指定索引位置的字符
int length() ： 获得字符串的字符长度
String toString() ： 将其他的字符串对象转换成String对象
String类
使用步骤：
1.查看类
java.lang.String ：此类不需要导入。
2.查看构造方法
public String() ：初始化新创建的 String对象，以使其表示空字符序列。
public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
构造举例，代码如下：
// 无参构造
String str = new String（）；
// 通过字符数组构造
char chars[] = {'a', 'b', 'c'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);
Java.lang.String类，不可变字符序列。
Java字符串就是Unicode字符序列，例如字符串“Java”就是4个Unicode字符J,a,v,a组成的。
java没有内置的字符串类型，而是在标准java类库中提供了一个预定义的类String，
每个用双引号括起来的字符串都是String类的一个实例。
字符串连接可以用+（只要+有一侧是字符串结果就是字符串）或concat()方法。
String类对象代表不可变的Unicode字符序列，因此可以将String对象称为“不可变对象”。
“不可变对象”指的是对象内部的成员变量的值无法再改变（就是个常量），看String类的源码：
发现字符串内容全部存储到value[]数组中，而变量value是final类型，也就是常量（即只能被赋值一次）。
**equals判断字符串内容值相等，==判断字符串对象引用相等。 **
String类是最常用的字符串操作类，使用的是Unicode编码，一个英文字符占一个字节，一个中文字符占两个字节。在UTF-8中，一个中文字符占3个字节。这个类中有大量的字符串的操作方法，而且这个类使用也有点特殊，String类的使用规则：
- 在Java程序中，使用双引号围起来的内容就是String的对象
- String类的对象一旦声明，则无法改变【在堆内存空间中声明的字符串无法改变】
- 字符串的内容的比较不是使用==，而是使用equals()方法
- 字符串在声明的时候，会先到堆内存中，寻找是否有存在相同内容的内存空间，有的话，直接使用，没有则开辟新空间。
String s1 = "222";
String s2 = "222";
String s3 = new String("222");
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
//字符串会先去常量池找是否有存在相同内容，没有再自己new
//new是自己开辟个空间存对象
这个四个规则导致String类对象在重复叠加的时候，效率特别低，所以不会使用String，而是使用StringBuffer或者StringBuilder，一般使用StringBuilder效率高。
String类中常用的构造方法：
public String() : 创建一个没有内容的字符串对象
public String(byte[] bytes)：创建一个带有指定字节数组的字符串
public String(String original):创建带有指定内容的字符串对象
public String(char[] value)：创建一个带有指定字符数组的字符串
public String(StringBuffer buffer)：创建一个带有指定StringBuffer对象的字符串
public String(StringBuilder builder)：创建一个带有指定StringBuilder对象的字符串
public String(byte[] bytes,Charset charset)：创建一个带有指定字节数组的字符串，并且按照指定的字符集
public String(byte[] bytes,int offset,int length)：创建一个带有指定字节数组部分长度的字符串
public String(byte[] bytes,int offset,int length,Charset charset)：创建一个带有指定字节数组部分长度的字符串，并且按照指定的字符集
public String(byte[] bytes,int offset,int length,String charsetName)throws UnsupportedEncodingException：创建一个带有指定字节数组部分长度的字符串，并且按照指定的字符集
public String(byte[] bytes,String charsetName)throws UnsupportedEncodingException：创建一个带有指定字节数组的字符串，并且按照指定的字符集
public String(char[] value,int offset,int count)：创建一个带有指定字符数组一部分的字符串
字符串的操作方法大都集中在String类中：
char charAt(int index) : 返回指定索引位置的字符
int length() ： 获得字符串的字符长度
String toString() ： 将其他的字符串对象转换成String对象
public String concat(String str)：字符串追加str的内容，字符串连接还可以用+。
public boolean contains(CharSequence s) ：是否包含指定内容
public boolean endsWith(String suffix)：判断字符串是否以指定的内容结尾
（startsWith以指定的内容开头）
public boolean equals(Object anObject)：比较字符串内容是否相同
boolean equalsIgnoreCase(String other) :如果字符串与other相等（忽略大小写）
public byte[] getBytes()：将字符串转换成字节数组
public char[] toCharArray()：将字符串转换成字符数组
public byte[] getBytes(Charset charset)：将字符串以指定的字符集转换成字节数组
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException：将字符串以指定的字符集转换成字节数组
public int indexOf(String str)：返回指定字符串在字符串中的索引位置，不存在返回-1
public int indexOf(String str,int fromIndex)：返回指定字符串在字符串中从fromIndex开始的索引位置，不存在返回-1
public boolean isEmpty()：判断字符串是否是空串
public int lastIndexOf(String str)：返回指定字符串在字符串中最后一次出现的索引位置，不存在返回-1
public int lastIndexOf(String str, int fromIndex)：同上，formIndex表示从指定位置开始
public boolean matches(String regex)：校验字符串是否是指定的内容
public String replace(char oldChar,char newChar)：进行字符替换
public String replace(CharSequence target,CharSequence replacement)：进行字符串替换
public String replaceAll(String regex,String replacement)：进行字符串替换
public String replaceFirst(String regex,String replacement)：替换第一个匹配的内容
public String[] split(String regex)：按照指定的内容进行字符串的拆分
public String substring(int beginIndex)：字符串截取，从beginIndex开始，到最后
public String substring(int beginIndex,int endIndex)：字符串截取，从beginIndex开始，到endIndex-1结束，java中索引从0开始，左闭右开
public String toLowerCase()：将字符串的所有字母变小写
public String toUpperCase()：将字符串的所有字母变大写
public String trim()：去除字符串的前后空格
基本数据类型转字符串：valueOf方法，或者加空串（+""）。Integer和Character这两个包装类特殊点。
字符串转基本数据类型：包装类中的parseXxx()静态方法。
在JDK1.5后，可以自动装箱拆箱。
自动装箱的数据处于需要对象的环境中，会自动转为“对象”。
在JDK1.5以前，这样的代码Integer i =5是错误的。必须通过Integer i = new Integer(5)。
在JDK1.5后，可以自动装箱拆箱，Integer i =5是可以的，
因为JVM为我们执行了Integer i = Integer.valueOf(5)这样的操作。
自动拆箱，每当需要一个值时，对象会自动转成基本数据类型，没必要去调用intValue()。
如Integer i =5; int j = i;这样的过程就是自动拆箱。
自动装箱过程是通过调用包装类的valueOf()方法实现的。
自动拆箱过程是通过调用包装类的如intValue()方法实现的。
String类对正则的支持：正则表达式简称正则，主要是完成字符串的校验，替换，拆分，正则表达式最早出现在PHP这门语言中，得到了广泛的好评，而后在各个语言中开始使用，Java使用JDK1.4开始引入正则表达式，在JDK中Pattern和Matcher是正则操作的核心类，Pattern用于进行正则的规则定义，以及进行字符串拆分及校验，Matcher用于进行正则的替换。常用的正则规则如下：
简短表达式
\d : 表示数字
\D ：表示非数字
\s ：表示空格，制表符，换行
\S ：表示非空格，非制表符，非换行
\w ：表示数字 字母 下划线
\W : 表示非数字 字母 下划线
[abc] : 表示要么是a要么是b要么是c
[^abc] : 表示不是a，不是b，不是c
[a-zA-Z] : 表示所有的字母
[a-z] : 表示所有的小写字母
[A-Z] : 表示所有的大写字母
[a-d[m-p]]：表示a-d的小写字母，或者是m-p的小写字母
[a-z&&[def]]：表示a-z的所有的小写字母，并且是d或者e或者f
[a-z&&[^bc]]：表示a-z的所有的小写字母，并且不是b和不是c
[a-z&&[^m-p]]：表示a-z的所有的小写字母，并且不是m-p之间的
次数相关
X? ： 表示X出现了一次或者0次
X* ： 表示X出现了0次或者多次
X+ ： 表示X出现了一次或者多次
X{n} ： 表示X恰好出现了n此
X{n,} ：表示X出现的次数不小于n次
X{n,m} ： 表示X出现的次数恰好在n到m之间
或链接
(X|Y) : 要么是X要么是Y
特殊
. 表示任意字符
$ 表示正则结束
^ 表示正则开始
String类中支持正则的方法：
public boolean matches(String regex)：校验字符串是否是指定的内容
public String replaceAll(String regex,String replacement)：进行字符串替换
public String replaceFirst(String regex,String replacement)：替换第一个匹配的内容
public String[] split(String regex)：按照指定的内容进行字符串的拆分
以上的方法如果第一次参数传入的是正则表达式，则表示根据根据正则进行校验，根据正则进行替换所有匹配内容，根据正则替换第一个匹配内容，根据正则进行字符串的拆分。
范例：校验一个字符串是否全部由数字组成
package com.wanbangee.charsequence;
public class StringDemo02 {
public static void main(String[] args) {
String s = "464765464d7894654";
// char c[] = s.toCharArray();
// boolean flag = true;//默认表示全部是数组
// for (char d : c) {
// if (d >= '0' && d <= '9') {
//
// }else {
// flag = false;
// break;
// }
// }
// if(flag) {
// System.out.println("字符串全部由数字组成");
// }else {
// System.out.println("字符串不全部是由数字组成");
// }
if(s.matches("\\d+")) {
System.out.println("字符串全部由数字组成");
}else {
System.out.println("字符串不全部是由数字组成");
}
}
}
范例：检验一个字符串是否是符合邮箱格式(mpp_ff@163.com)
package com.wanbangee.charsequence;
public class StringDemo03 {
public static void main(String[] args) {
String s= "jjm_ff@163.com";
String pattern = "\\w{3,16}@\\w{2,8}\\.(com|cn|gov|edu|com\\.cn)";
if(s.matches(pattern)) {
System.out.println("是邮箱");
}else {
System.out.println("不是邮箱");
}
}
}
范例：字符串的替换，将一个字符串中的数字全部替换成 “你好”
package com.wanbangee.charsequence;
public class StringDemo04 {
public static void main(String[] args) {
String s = "asdf23jqseflqwkfhasieue23asdfasdfmnase9023423";
// s = s.replaceAll("\\d+", "你好");
s = s.replaceFirst("\\d+", "你好");
System.out.println(s);
}
}
范例：正则拆分
package com.wanbangee.charsequence;
public class StringDemo05 {
public static void main(String[] args) {
String s = "1234;lksj1j23k23jh123kldhqw4ryjhaKLSDFJHQW4327";
String sa[] = s.split("\\d+");
for (String string : sa) {
System.out.println(string);
}
}
}
正则常用在表单验证上面。
StringBuffer类
String对象一旦声明，则无法改变，这是String的缺点[不可变的字符序列]，StringBuffer代表的是可变字符序列，可以对字符串的内容进行增删改操作，很多方法和String类的方法一样，但是StringBuffer是可变长度的。
StringBuffer类的常用构造方法：
public StringBuffer() ： 创建容量为16个字节缓冲区的StringBuffer对象
public StringBuffer(int capacity) ： 创建容量为指定字节数量缓冲区的StringBuf对象
public StringBuffer(String str)：创建指定内容的StringBuffer缓冲区对象
StringBuffer常用的方法：(String中出现的我们不在列出)
public StringBuffer append(Object obj) ： StringBuffer对象的内容追加，可以是任意的类型。
public StringBuffer insert(int index,Object obj) : 在指定索引位置插入指定内容
public StringBuffer reverse()：反转字符串内容
public StringBuffer delete(int start, int end)：删除指定从start索引开始到end索引结束的内容
public void setCharAt(int index,char ch)：指定位置设置为指定字符
package com.wanbangee.charsequence;
public class StringBufferDemo01 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("Hello World");//内容追加
System.out.println(sb.toString());
sb.insert(0, "Hello everbBody");//指定位置插入指定内容
System.out.println(sb.toString());
sb.setCharAt(1, '哈');//指定位置设置为指定字符
System.out.println(sb.toString());
sb.reverse(); //反转
System.out.println(sb.toString());
}
}
StringBuilder类
StringBuilder和StringBuffer类是非常类似的，都代表可变的字符序列，方法也一样。
append/delete/deleteCharAt/insert/inverse
StringBuilder常用方法：
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 26; i++) {
char temp = (char)('a'+i);
sb.append(temp);//追加内容
}
System.out.println(sb);
sb.reverse();//倒序（反转）
System.out.println(sb);
sb.setCharAt(2, '马');//改变指定位置的字符
System.out.println(sb);
sb.insert(0, '我');//在指定位置插入字符
System.out.println(sb);
sb.insert(0, '我').insert(1, '爱').insert(2, '你');
//链式调用，该方法调用了return this把自己返回了
System.out.println(sb);
sb.delete(1, 3);//删除指定区间（区间左闭右开）内容，和insert一样返回自己，可以链式调用
System.out.println(sb);
StringBuilder sb = new StringBuilder("abcdef");
System.out.println(sb);
sb.setCharAt(3, 'D');
System.out.println(sb);
总结
String：不可变的字符序列
StringBuffer ： 可变的字符序列，是线程安全的，效率低，JDK1.0就存在
StringBuilder： 可变的字符序列，线程不安全，效率高，JDK1.5才有（ 一般使用它）
通过观察StringBuilder和StringBuffer发现char value[]是可变的数组，其字符序列可变。
StringBuilder线程不安全、效率高（一般使用它）。StringBuffer线程安全、效率低。
日期时间操作类
System类
在java.lang.System类中提供了获得时间戳的方法，时间戳表示的是格林尼治时间1970年1月1号0时0分0秒0毫秒以来的毫秒数，所以是一个long类型。现在是2020年1月1号0时0分0秒0毫秒，那么从1970年以来正好50年，时间戳 = 50365246060*1000。
public static long currentTimeMillis()
这个方法我们一般用来计算时间差。
举例：一段程序，从开始执行到执行结束，需要多长时间。
package com.wanbangee.datatime;
public class SystemDemo01 {
public static void main(String[] args) {
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
System.out.println("你好");
}
long end = System.currentTimeMillis();
System.out.println("运行所花时间为:" + (end-start) + "毫秒");
}
}
java.util.Date类
Java.util.Date一般我们只使用无参构造器获得系统当前时间，精确到毫秒，因为其他的构造方法基本上都已经过时。以后遇到日期处理：使用Canlendar日期类
public Date(){}
package com.wanbangee.datatime;
import java.util.Date;
public class DateDemo01 {
public static void main(String[] args) {
Date date = new Date();//获得系统当前时间
System.out.println(date);
System.out.println(d.getTime());//现在距离1970年1月1号0时0分0秒的毫秒数
}
}
常用的操作方法：
public long getTime() ： 获得Date对象的时间戳,单位是毫秒
除了以上的操作方法外，大部分都已经过时了。当然我们也可以使用过时的方法来进行响应的操作。
范例：取得Date对象的年，月，日，时，分，秒，毫秒
package com.wanbangee.datatime;
import java.util.Date;
public class DateDemo01 {
public static void main(String[] args) {
Date date = new Date();//获得系统当前时间
System.out.println("年:" + date.getYear()); //从1900年开始
System.out.println("月:" + (date.getMonth()+1));
System.out.println("日:" + date.getDate());
System.out.println("时:" + date.getHours());
System.out.println("分:" + date.getMinutes());
System.out.println("秒:" + date.getSeconds());
}
}
以上的操作虽然可以使用，但是都已经过时了，JDK不推荐。那么JDK推荐的是啥呢？
推荐的方式在Calendar类(日历类)中，该类中使用静态常量声明了所有的日历字段。
java.util.Calendar类
Calendar类是JDK推荐的日期时间的操作类，以后遇到日期处理：使用Canlendar日期类，定义了所有的日历字段，提供了大量的日历对象的操作方法。这个类的声明：
public abstract class Calendar
extends Object
implements Serializable, Cloneable, Comparable<Calendar>
发现这个类是一个抽象类，我们在使用的时候必须依靠子类，目前Calendar只有一个子类：GregorianCalendar，这个子类通过无参构造器也可以获得系统当前时间。
public GregorianCalendar()：构造系统当前时间的GregorianCalendar对象
public GregorianCalendar(int year,int month,int dayOfMonth)：指定年月日构造GregorianCalendar对象
public GregorianCalendar(int year,int month, int dayOfMonth,int hourOfDay,int minute)：指定年月日时分构造GregorianCalendar对象
public GregorianCalendar(int year,int month, int dayOfMonth,int hourOfDay,int minute,int second)：指定年月日时分秒构造GregorianCalendar对象
Calendar类中常用的日期时间的处理方法：
public abstract void add(int field, int amount)：指定的日历字段添加指定的数据
public final void clear()：清除所有日历字段的数据
public final void clear(int field)：清除指定日历字段的数据
public int get(int field)：获取指定日历字段的数据
public final Date getTime()：将Calendar对象转换成Date对象
public void set(int field,int value)：指定日历字段设置为指定的值
public final void set(int year,int month,int date,int hourOfDay,int minute,int second)：给Calendar设置指定的年月日时分秒
public final void setTime(Date date)：将Date日期数据设置给Calendar对象
以上的方法中，出现的入参为int field ,表示的日历字段，日历字段为静态的可通过类名调
public static final int DAY_OF_MONTH 表示这个月的第几天 日历字段
public static final int DAY_OF_YEAR 表示这年的第几天 日历字段
public static final int DAY_OF_WEEK 表示这个星期的第几天 日历字段
public static final int WEEK_OF_MONTH 表示这个月的第几周 日历字段
public static final int WEEK_OF_YEAR 这年的第几周 日历字段
public static final int YEAR 表示年日历字段
public static final int HOUR_OF_DAY 这天的第几个小时 日历字段(24小时)
public static final int HOUR 小时(12小时制)
public static final int MONTH 月 日历字段
public static final int MINUTE 分钟 日历字段
public static final int MILLISECOND 毫秒日历字段
public static final int SECOND 秒 日历字段
范例：获取当前时间的年月日时分秒毫秒的值
package com.wanbangee.datatime;
import java.util.Calendar;
import java.util.GregorianCalendar;
public class CalendarDemo01 {
public static void main(String[] args) {
Calendar calendar = new GregorianCalendar();//无参构造器为系统当前时间
System.out.println("年:" + calendar.get(Calendar.YEAR));
System.out.println("月:" + (calendar.get(Calendar.MONTH)+1));
System.out.println("日:" + calendar.get(Calendar.DAY_OF_MONTH));
System.out.println("时:" + calendar.get(Calendar.HOUR_OF_DAY));
System.out.println("分:" + calendar.get(Calendar.MINUTE));
System.out.println("秒:" + calendar.get(Calendar.SECOND));
System.out.println("毫秒:" + calendar.get(Calendar.MILLISECOND));
//设置日期的相关元素
Calendar c2 = new GregorianCalendar();
c2.set(Calendar.YEAR, 8012);
System.out.println(c2);
//日期的计算
Calendar c3 = new GregorianCalendar();
c3.add(Calendar.YEAR, -100);
System.out.println(c3) ;
//日期对象和时间对象的转化
Date d4 = c3.getTime();
Calendar c4 = new GregorianCalendar();
c4.setTime(new Date());
printCalendar(c4);
}
}
范例：获取当前时间前五年10月1号，时间为当前时间的日历字段数据
package com.wanbangee.datatime;
import java.util.Calendar;
import java.util.GregorianCalendar;
public class CalendarDemo02 {
public static void main(String[] args) {
Calendar calendar = new GregorianCalendar();//无参构造器为系统当前时间
calendar.add(Calendar.YEAR, -5);//前五年
calendar.set(Calendar.MONDAY, 9);//设置为10月
calendar.set(Calendar.DAY_OF_MONTH, 1);//设置为1号
System.out.println("年:" + calendar.get(Calendar.YEAR));
System.out.println("月:" + (calendar.get(Calendar.MONTH)+1));
System.out.println("日:" + calendar.get(Calendar.DAY_OF_MONTH));
System.out.println("时:" + calendar.get(Calendar.HOUR_OF_DAY));
System.out.println("分:" + calendar.get(Calendar.MINUTE));
System.out.println("秒:" + calendar.get(Calendar.SECOND));
System.out.println("毫秒:" + calendar.get(Calendar.MILLISECOND));
}
}
/**可视化日历程序(第一个版本)
* @author Administrator
*/
public class TestCalendar2 {
public static void main(String[] args) throws ParseException {
String str = "2020-9-10";
DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Date date = df.parse(str);
Calendar c = new GregorianCalendar();
c.setTime(date);
System.out.println("日\t一\t二\t三\t四\t五\t六");
c.set(Calendar.DAY_OF_MONTH, 1);
for(int i=0;i<c.get(Calendar.DAY_OF_WEEK)-1;i++){
System.out.print("\t");
}
int days = c.getActualMaximum(Calendar.DATE);
for(int i=1;i<=days;i++){
System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");
if(c.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY){
System.out.println(); //换行
}
c.add(Calendar.DAY_OF_MONTH, 1);
}
}
}
/** 可视化日历程序(第二个版本)
* @author Administrator
*/
public class TestCalendar3 {
public static void main(String[] args) throws ParseException {
System.out.println("请输入日期（格式：2020-9-10):");
Scanner scanner = new Scanner(System.in);
String str = scanner.nextLine();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Date date = df.parse(str);
Calendar c = new GregorianCalendar();
c.setTime(date);
int day = c.get(Calendar.DAY_OF_MONTH);
int days = c.getActualMaximum(Calendar.DATE);
System.out.println("日\t一\t二\t三\t四\t五\t六");
c.set(Calendar.DAY_OF_MONTH, 1);
for(int i=0;i<c.get(Calendar.DAY_OF_WEEK)-1;i++){
System.out.print("\t");
}
for(int i=1;i<=days;i++){
if(day == c.get(Calendar.DAY_OF_MONTH)){
System.out.print(c.get(Calendar.DAY_OF_MONTH)+"*\t");
}else{
System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");
}
if(c.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY){
System.out.println(); //换行
}
c.add(Calendar.DAY_OF_MONTH, 1);
}
}
}
java.text.DateFormat类
DataFormat类：把时间对象转化成指定格式的字符串，反之把指定格式的字符串转化成时间对象。
DataFormat是一个抽象类，一般使用它的子类SimpleDataFormat类来实现。
DateFormat类作用就是用于字符串和Date对象之间的格式转换，Format的意思就是个格式化的含义。
比如我们要将一个日期转换成字符串“2020-10-11 10:13:34.551”或者“2020/10/11 10:13:34.551”或者“2020年10月11日 10时13分34秒551毫秒”，这个时候我们必须使用DateFormat进行日期的格式化操作。
public abstract class DateFormat
extends Format
发现DateFormat类是一个抽象类，所以必须依靠子类，子类为SimpleDateFormat，子类常用的构造方法为：
public SimpleDateFormat(String pattern){}
构造方法中的参数为指定的格式，这个格式如何定义，需要依靠SimpleDateFormat中定义的格式化规则：
如何定义格式呢，如下所示：
2020-10-11 10:13:34.551 --->yyyy-MM-dd HH:mm:ss.SSS
2020/10/11 10:13:34.551---->yyyy/MM/dd HH:mm:ss.SSS
2020年10月11日 10时13分34秒551-->yyyy年MM月dd日 HH时mm分ss秒SSS毫秒
y年几位用几个y,M月，d日，H时（24小时制度，h是12小时制），m分，s秒，S毫秒
DateFormat类中定义的转换方法：
public final String format(Date date)：将Date对象转换成字符串
public Date parse(String source)throws ParseException：将字符串转换成Date对象
package com.wanbangee.datatime;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatDemo01 {
public static void main(String[] args) {
Date date = new Date();//系统当前时间
// DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
// DateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒SSS毫秒");
String str = df.format(date);//进行转换
System.out.println(date);
System.out.println(str);
}
}
相反，字符串也可以转换成日期格式。范例：
package com.wanbangee.datatime;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatDemo02 {
public static void main(String[] args) throws Exception {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
String s = "2008-08-08 20:08:08.000";
Date date = df.parse(s);//将字符串转换成Date类型
System.out.println(date);
}
}
如果需要转换的字符串和指定的格式不一样，一定会出现转换异常。
Math类
Math类是java.lang下的一个类，里面定义了一系列的数学运算的静态方法，比如求绝对值，正弦，余弦…这些方法大都不需要关注，需要关注的方法有4个：
四舍五入:round(double a) ,四舍五入后取整，结果为long型，整数
求随机数:random() ，取得【0，1）的随机数，结果为double型，保留一位小数
向下取整：floor(double a)，结果为double型，保留一位小数
向上取整：ceil(double a)，结果为double型，保留一位小数
package com.wanbangee.datatime;
public class MathDemo01 {
public static void main(String[] args) {
long x = Math.round(12341234234523.123423453456);//四舍五入
System.out.println(x);
for(int i = 0;i<10;i++) {
System.out.println(Math.random()); //取【0，1）随机数
}
System.out.println(Math.ceil(1341324.12342353));;//向上取整
System.out.println(Math.floor(1341324.12342353));;//向上取整
}
}
范例：四舍五入后保留两位小数，一般Math.round结果为整数long型。
package com.wanbangee.datatime;
public class MathDemo02 {
public static void main(String[] args) {
double money = 8145.876345;
double money2 = Math.round(money*100)/100.00;
System.out.println(money2);
}
}
范例：取1-10之间的随机数
package com.wanbangee.datatime;
public class MathDemo03 {
public static void main(String[] args) {
int min = 5;
int max = 10;
for (int i = 0; i < 10; i++) {
System.out.println(Math.round(Math.random()*(max-min) + min));
}
}
}
对于取随机数来说，还有一个类 Random类，在java.util包中。
Random random = new Random();//获得随机数对象
for (int i = 0; i < 100; i++) {
//public int nextInt(int n)。random.nextInt(n)：产生【0，n）之间随机整数
//public int nextInt()不给参数n就会产生-232 到232 之间随机整数，都是很大值的随机数
System.out.println(random.nextInt(10));//产生【0，10）之间随机整数
}
BigInteger类和BigDecimal类
BigInteger类
我们知道Integer作为int类型的包装类，能存储的最大范围2^31 -1,
java.math.BigInteger类的数字的范围相比Integer来说要大的多，可以支持任意精度的整数。
其常用构造方法：public BigInteger(String val)，将 BigInteger 的十进制字符串表示形式转换为 BigInteger。字符到数字的映射由 Character.digit 提供。表示构造带有指定数值的BigInteger对象。常用方法如下：
public BigInteger abs() ： 绝对值
public BigInteger add(BigInteger val)：相加
public BigInteger divide(BigInteger val)：相除
public BigInteger multiply(BigInteger val)：相乘
public BigInteger subtract(BigInteger val)：相减
BigDecimal
一般的Float和Double类可以用来做科学计算或者工程计算，但是在商业计算中，
要求的数字精度比较高，所以用java.math.BigDecimal类，支持任意精度的小数位。
常用的构造方法：public BigDecimal(String val)，将 BigDecimal 的字符串表示形式转换为 BigDecimal。表示构造带有指定数值的BigDecimal对象。常用方法如下：
public BigDecimal abs() ： 绝对值
public BigDecimal add(BigDecimal val)：相加
public BigDecimal divide(BigDecimal val)：相除
public BigDecimal multiply(BigDecimal val)：相乘
public BigDecimal subtract(BigDecimal val)：相减
总结：
1. 要弄清楚String，StringBuffer和StringBuilder的区别及联系
区别：
- String是不可变的字符序列
- StringBuffer是可变的字符序列 ，线程安全的，效率低
- StringBuilder是可变的字符序列，线程不安全的，效率高
联系：三个类都是实现CharSequence接口的类，所以都是实现类。
2.String类中的大量的字符串的操作方法，都必须要非常熟悉。
3.String类中提供了对正则支持的方法，支持正则校验，正则替换和正则拆分，对于正则表达式的规则，常用的要记住。
4.StringBuffer和StringBuilder的操作方法一模一样。
5.一定要弄清楚Calendar，Date，String之间的转换问题，Calendar通过setTime(Date date) 方法将Date对象的日期时间设置给Calendar，
通过getTime()方法将Calendar的日期时间返回为一个Date对象，Date和String通过DateFormat进行相互转换，方法为format(Date date)和parse(String string)
6.System类中提供了获得系统当前时间的时间戳的方法，一般用于计算执行的时间。
7.Math类中记住的是四舍五入方法和取随机数的方法，当然要记住保留小数位的四舍五入和定范围的随机数获取。
8.BigInteger表示范围无限的整型，BigDecimal表示范围无限的浮点型。
练习：
3.获得系统当前时间上月最后一天和这个月的第一天，并且以“yyyy-MM-dd”格式显示。
package com.wanbangee.datatime;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
public class DateFormatDemo03 {
public static void main(String[] args) {
Calendar c = new GregorianCalendar();//系统当前时间的日历类对象
c.set(Calendar.DAY_OF_MONTH, 1);//设置为这个月的第一天
//Calendar对象不能使用DateFormat转成，所以必须要先将Calendar转换为Date类型
Date date1 = c.getTime();//这个月的第一天
c.add(Calendar.DAY_OF_MONTH, -1);//当前月份第一天-1 就是上个月的最后一天
Date date2 = c.getTime();//上个月的最后一天（将Calendar日历对象日期时间转化为Date日期时间对象）
DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
String dString1 = df.format(date1);
String dString2 = df.format(date2);
System.out.println("这个月的第一天是：" + dString1);
System.out.println("上个月的最后一天是：" + dString2);
Calendar calendar = new GregorianCalendar();
calendar.setTime(date2);//设置为上个月的最后一天（将Date日期时间设置到Calendar日历中去）
System.out.println("年:" + calendar.get(Calendar.YEAR));
System.out.println("月:" + (calendar.get(Calendar.MONTH)+1));
System.out.println("日:" + calendar.get(Calendar.DAY_OF_MONTH));
System.out.println("时:" + calendar.get(Calendar.HOUR_OF_DAY));
System.out.println("分:" + calendar.get(Calendar.MINUTE));
System.out.println("秒:" + calendar.get(Calendar.SECOND));
System.out.println("毫秒:" + calendar.get(Calendar.MILLISECOND));
}
}
Date和Calendar，Date和String的像话设置或者转换的问题：
4.随机点名，随机点我们班12个人的名字，一次一个。
String[] str = {"A1","A2","A3","A4","A5"};
int a = (int) (Math.random()*(str.length-1)+1);
System.out.println(str[a]);
List<String> names = new ArrayList<>();
names.add("小马");
names.add("老马");
names.add("小闫");
names.add("小王");
names.add("小周");
names.add("小黄");
names.add("小付");
names.add("小符");
names.add("小高");
names.add("小游");
names.add("小刘");
names.add("小邱");
Scanner sc = new Scanner(System.in);
int temp = 0;
do {
if(names.size() != 0) {
System.out.println("输入1表示抽奖，输入0退出");
System.out.print("请输入1或者0");
temp = sc.nextInt();
int min = 0;
int max = names.size()-1;
int index = (int) Math.round(Math.random()*(max-min) + min);
System.out.println("恭喜" + names.get(index) + "中奖了");
names.remove(index);//移除
}else {
System.exit(0);//退出
}
}while(temp != 0);
循环累加添加字符串使用StringBuilder。
// String str = "";
// for (int i = 0; i < 5000; i++) {
// str += i; //相当于产生5000个i对象和5000个str对象
// }//程序跑蹦调，后面使用服务器会使服务器崩溃。
// System.out.println(str);
//循环累加添加字符串使用StringBuilder。
StringBuilder sb = new StringBuilder("");
for (int i = 0; i < 5000; i++) {
sb.append(i);
}
System.out.println(sb);
177
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
