这些Java常用类，你必须要学会，还不快快收藏？（近两万字详细介绍）

概述

在Java中，类是一个非常重要的东西，想要学好Java（做到简历上的精通Java😄😄😄），我们不仅要自己能够根据业务需求创建合适的类，进行相关的开发，还要必须要学会使用Java常用类，这样才能获得更高的效率。在Java中常用类主要包括：

• 包装类
• 和数学相关的类（Math）
• String类（字符串）
• 可变字符序列（StringBuilder和StringBuffer）
• 时间日期（Date）

下面呢，就介绍下Java常用类，帮助各位更进一步。（内容比较多，水平有限，感谢指正！）

包装类

前面有文章说过这个内容，可以看下：近7000字长文详细讲解Java包装类，面试稳了

和数学相关的类

在计算机中进行数学计算是及其重要的一项工作，因此非常用必要提前设计一个类，来满足基本数学函数所需要的属性和方法。在Java中，这个类就是和数学相关的一个常用类，即Math类。其类在源码中的定义如下：

public final class Math {

    private Math() {}
    
    public static final double PI = 3.14159265358979323846; //属性举例
    
	public static double sin(double a) { //方法举例
        return StrictMath.sin(a);
        }
   	 ...//省略了的方法和属性
    }

Math 被定义成了final类，所以是不能被继承的；另外Math的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

Math类中常用的属性和方法列举如下：

Math.E   		//欧拉常数，也是自然对数的底数，约等于 2.718
Math.PI 		//圆周率，一个圆的周长和直径之比，约等于 3.14159。
Math.abs(x) 	//返回一个数的绝对值。
Math.cbrt(x)	//返回一个数的立方根。
Math.ceil(x)	//返回大于一个数的最小整数，即一个数向上取整后的值。
Math.exp(x)		//返回欧拉常数的参数次方，Ex，其中 x 为参数，E 是欧拉常数（2.718...，自然对数的底数）。
Math.floor(x)	//返回小于一个数的最大整数，即一个数向下取整后的值。
Math.fround(x)	//返回最接近一个数的单精度浮点型表示。
Math.hypot([x[, y[, …]]])//返回其所有参数平方和的平方根。
Math.max([x[, y[, …]]])//返回零到多个数值中最大值。
Math.min([x[, y[, …]]])//返回零到多个数值中最小值。
Math.pow(x, y)	//返回一个数的 y 次幂。
Math.random()	//返回一个 0 到 1 之间的伪随机数。
Math.round(x)	//返回四舍五入后的整数。
Math.sign(x)	//返回一个数的符号，得知一个数是正数、负数还是 0。
Math.sqrt(x)	//返回一个数的平方根。
Math.toSource()//返回字符串 "Math"。
Math.trunc(x)	//返回一个数的整数部分，直接去除其小数点及之后的部分。
Math.imul(x, y)	//返回 32 位整数乘法的结果。
Math.log(x)		//返回一个数的自然对数（㏒e，即 ㏑）。
Math.log10(x)	//返回一个数以 10 为底数的对数。
Math.log2(x)	//回一个数以 2 为底数的对数。

String类

String类代表字符串，在Java中字符串属于对象，Java 提供了 String 类创建和操作字符串。其类在源码中的定义如下：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {

		public String() {
        this.value = "".value; //构造方法举例1；String有很多的构造方法
  	  }
  	    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);//构造方法举例2；String有很多的构造方法
	    }

		 private static void checkBounds(byte[] bytes, int offset, int length){
		... //静态构造方法举例；类名直接调用
		}
    	 public String replace(char oldChar, char newChar){
		... //非静态方法举例；对象名调用
		}
	... //其他内容省略
    

从源码中我们可以看出：

• 字符串是常量；它们的值在创建之后不能更改；其构造方法有多种；

• 其方法有静态和非静态的，即有的需要通过类名调用，有的需要通过对象名调用。

• 字符串的对象是不可变对象，意味着一旦进行修改，就会产生新对象，因此其不适合大量修改字符串的场景使用。字符串对象设计为不可变,那么所以字符串有常量池来保存很多常量对象。

• String对象内部是用字符数组进行保存的；例如：“abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ }`。

下面进一步说明String类及其常用的方法。

创建字符串对象

使用构造方法

使用构造方法创建字符串有三种形式：

• 直接赋值，类似于基本数据类型就可以（创建一个，在常量池中）
• 通过对象赋值，参数是字符串（创建两个对象，首先指向堆中的一个字符串对象，然后堆中字符串的value数组指向常量池中常量对象的value数组）
• 也是使用通过对象赋值，只不过参数是数组，数组里面是char类型的数据（创建两个对象，同上）

  @Test
    public void test1(){
        //创建String对象的三种方法
        String str1 = "method1";
        String str2 = new String("method2");
        char[] chars = {'m','e','t','h','o','d','3'};
        String str3 = new String(chars);

        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
    }

使用静态方法

这是String类自定义的静态方法；介绍如下：

• copyValueOf(char data[]) 返回指定数组中表示该字符序列的 String
• copyValueOf(char data[], int offset, int count)返回指定数组中表示该字符序列的 String
• valueOf(char c)返回指定数组中表示该字符序列的 String
• valueOf(char data[], int offset, int count)返回指定数组中表示该字符序列的 String
• valueOf(int i) 支持各种数据类型(int改为其他的也行)，返回各种数据类型的value参数的字符串表示形式。

其源代码如下：

// 返回指定数组中表示该字符序列的 String
 public static String copyValueOf(char data[]) {
        return new String(data);
    }
//返回指定数组中表示该字符序列的 String
 public static String copyValueOf(char data[], int offset, int count) {
        return new String(data, offset, count);
    }

//返回指定数组中表示该字符序列的 String
    public static String valueOf(char c) {
        char data[] = {c};
        return new String(data, true);
    }
//返回指定数组中表示该字符序列的 String
public static String valueOf(char data[], int offset, int count) {
        return new String(data, offset, count);
    }
//支持各种数据类型(int改为其他的也行)，返回各种数据类型的value参数的字符串表示形式。
 public static String valueOf(int i) {
        return Integer.toString(i);
    }

使用" " + 拼接

Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持（toString()方法）。在String类型中，任意数据类型与" "进行拼接，结果都是字符串。

代码示例如下：

public class Demo {
    public static void main(String[] args) {
        int num = 123456;
        String s = "" +num;
        System.out.println(s);

        Student stu = new Student();
        String s2 = stu + "";//自动调用对象的toString()，然后与""进行拼接
        System.out.println(s2);
    }
}

class Student {
    int id;
    String name;

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

这里既然说到了拼接，就不得不说字符串其拼接的特殊性问题，即不同形式创建的字符串所存储的位置是不同的，这也就使得即使字符串内容相同，但进行 == 比较时候，结果不同。其具体分类如下：

• 常量和常量：结果是常量池
• 常量与变量 或 变量与变量：结果是堆
• 任何形式拼接后调用intern方法：结果在常量池
• 使用contcat()方法拼接：结果在堆

代码示例：

 @Test
    public void test06(){

        String s1 = "hello"; //变量
        String s2 = "world";
        String s3 = "helloworld";

        String s4 = (s1 + "world").intern();//把拼接的结果放到常量池中
        String s5 = (s1 + s2).intern();

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//true
    }

    @Test
    public void test05(){
        final String s1 = "hello"; //final变成常量了
        final String s2 = "world";
        String s3 = "helloworld"; //变量

        String s4 = s1 + "world";//s4字符串内容是helloworld，s1是常量，"world"常量，常量 + 常量 结果在常量池中
        String s5 = s1 + s2;//s5字符串内容是helloworld，s1和s2都是常量，常量 + 常量 结果在常量池中
        String s6 = "hello" + "world";//常量 + 常量 结果在常量池中，因为编译期间就可以确定结果

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//true
        System.out.println(s3 == s6);//true
    }

    @Test
    public void test04(){
        String s1 = "hello"; //变量
        String s2 = "world";
        String s3 = "helloworld";

        String s4 = s1 + "world"; //s4字符串内容是helloworld，s1是变量，"world"常量，变量 + 常量的结果在堆中
        String s5 = s1 + s2;//s5字符串内容是helloworld，s1和s2都是变量，变量 + 变量的结果在堆中
        String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果

        System.out.println(s3 == s4);//false
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//true
    }
}

 @Test
    public void test03(){
        String str = "hello";
        String str2 = "world";
        String str3 ="helloworld";

        String str4 = "hello".concat("world"); //concat方法拼接，哪怕是两个常量对象拼接，结果也是在堆。
        String str5 = "hello"+"world";

        System.out.println(str3 == str4);//false
        System.out.println(str3 == str5);//true
    }

字符串对象的比较

字符串的比较有很多种方式，不同方式比较的东西和形式不一样。其比较方式如下：

• ==：比较是对象的地址
• equals：String类型重写equals方法，比较是对象的内容（区分大小写）
• equalsIgnoreCase：比较的是对象的内容（不区分大小写）
• compareTo：String类型重写了Comparable接口的抽象方法，自然排序，按照字符的Unicode编码值进行比较大小的（区分大小写）
• compareToIgnoreCase：按照字符的Unicode编码值进行比较大小（不区分大小写）

代码示例

import org.junit.Test;
public class Demo7 {

    // ==：比较的是地址

    @Test
    public void test1(){
        String str1 = "hello";
        String str2 = "hello";
        System.out.println(str1 == str2);//true

        String str3 = new String("hello");
        String str4 = new String("hello");
        System.out.println(str1 == str4); //false
        System.out.println(str3 == str4); //false
    }

    //     equals：比较是对象的内容，因为String类型重写equals，区分大小写
    @Test
    public void test2(){
        String str1 = "hello";
        String str2 = "hello";
        String str5 = "Hello";
        System.out.println(str1.equals(str2));//true

        String str3 = new String("hello");
        String str4 = new String("hello");
        System.out.println(str1.equals(str3));//true
        System.out.println(str3.equals(str4));//true
        System.out.println(str1.equals(str5));//false
    }

    //     equalsIgnoreCase：比较的是对象的内容，不区分大小写
    @Test
    public void test3(){
        String str1 = new String("hello");
        String str2 = new String("HELLO");
        System.out.println(str1.equalsIgnoreCase(str2)); //true
    }

    //compareTo：String类型重写了Comparable接口的抽象方法，自然排序，按照字符的Unicode编码值进行比较大小的，严格区分大小写
    @Test
    public void test4(){
        String str1 = "hello";
        String str2 = "world";
        int i = str1.compareTo(str2);
        System.out.println(i);//小于0的值

    }

    //compareToIgnoreCase：不区分大小写，其他按照字符的Unicode编码值进行比较大小
    @Test
    public void test5(){
        String str1 = "hello";
        String str2 = "HELLO";
        int i = str1.compareToIgnoreCase(str2);
        System.out.println(i);//0
    }
}

字符串的常用方法

String类是非常常用的类，其方法也有很多，但并不是所有的方法都使用的那么频繁，所以在这里介绍了字符串的常用方法是有必要滴。常用方法介绍如下：

查找相关

• boolean contains(xx)：是否包含xx
• int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1
• int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1
• String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。

代码示例

@Test
	public void test01(){
		String str = "这是一个有关查找的测试方法，这个方法很棒";
		System.out.println("是否包含“这个”：" + str.contains("这个"));
		System.out.println("“这”出现的第一次下标：" + str.indexOf("这"));
		System.out.println("“这”出现的最后一次下标：" + str.lastIndexOf("这"));
	}

字符串相关

• String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
• char charAt(index)：返回[index]位置的字符
• char[] toCharArray()： 将此字符串转换为一个新的字符数组返回
• String(char[] value)：返回指定数组中表示该字符序列的 String。
• String(char[] value, int offset, int count)：返回指定数组中表示该字符序列的 String。
• static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String
• static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String
• static String valueOf(char[] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String
• static String valueOf(char[] data) ：返回指定数组中表示该字符序列的 String

@Test
	public void test01(){
		String str = "helloworldjava";
		String sub1 = str.substring(5); //截取5到最后
		String sub2 = str.substring(5,10);//截取5到10
		System.out.println(sub1);
		System.out.println(sub2);
	}

	@Test
	public void test02(){
		String fileName = "快速学习Java的秘诀.dat";
		//截取文件名
		System.out.println("文件名：" + fileName.substring(0,fileName.lastIndexOf(".")));
		//截取后缀名
		System.out.println("后缀名：" + fileName.substring(fileName.lastIndexOf(".")));
	}
@Test
	public void test03(){
		//将字符串中的字符按照大小顺序排列
		String str = "helloworldjava";
		char[] array = str.toCharArray();
		Arrays.sort(array);
		str = new String(array);
		System.out.println(str);//输出
	}
	
	@Test
	public void test04(){
		//将首字母转为大写
		String str = "jack";
		str = Character.toUpperCase(str.charAt(0));
		System.out.println(str);
	}

解码编码相关

• byte[] getBytes()：编码，把字符串变为字节数组，按照平台默认的字符编码进行编码
• byte[] getBytes(字符编码方式)：按照指定的编码方式进行编码
• new String(byte[] ) 或 new String(byte[], int, int)：解码，按照平台默认的字符编码进行解码
• new String(byte[]，字符编码方式 ) 或new String(byte[], int, int，字符编码方式)：解码，按照指定的编码方式进行解码

代码示例

	/*
	 * GBK，UTF-8，ISO8859-1所有的字符编码都向下兼容ASCII码
	 */
	public static void main(String[] args) throws Exception {
		String str = "中国";
		System.out.println(str.getBytes("ISO8859-1").length);// 2
		// ISO8859-1把所有的字符都当做一个byte处理，处理不了多个字节
		System.out.println(str.getBytes("GBK").length);// 4 每一个中文都是对应2个字节
		System.out.println(str.getBytes("UTF-8").length);// 6 常规的中文都是3个字节

		/*
		 * 不乱码：（1）保证编码与解码的字符集名称一样
		 * 		（2）不缺字节
		 */
		System.out.println(new String(str.getBytes("ISO8859-1"), "ISO8859-1"));// 乱码
		System.out.println(new String(str.getBytes("GBK"), "GBK"));// 中国
		System.out.println(new String(str.getBytes("UTF-8"), "UTF-8"));// 中国
	}

正则匹配相关

• boolean matchs(正则表达式)：判断当前字符串是否匹配某个正则表达式

常用正则表达式：

字符类

• [abc]：a、b 或 c（简单类）

• [^abc]：任何字符，除了 a、b 或 c（否定）

• [a-zA-Z]：a 到 z 或 A 到 Z，两头的字母包括在内（范围）

预定义字符类

• .：任何字符（与行结束符可能匹配也可能不匹配）

• \d：数字：[0-9]

• \D：非数字： [^0-9]

• \s：空白字符：[ \t\n\x0B\f\r]

• \S：非空白字符：[^\s]

• \w：单词字符：[a-zA-Z_0-9]

• \W：非单词字符：[^\w]

边界匹配器

• ^：行的开头

• $：行的结尾

Greedy 数量词

• X?：X，一次或一次也没有

• X*：X，零次或多次

• X+：X，一次或多次

• X{n}：X，恰好 n 次

• X{n,}：X，至少 n 次

• X{n,m}：X，至少 n 次，但是不超过 m 次

Logical 运算符

• XY：X 后跟 Y

• X|Y：X 或 Y

• (X)：X，作为捕获组

代码示例

	@Test
	public void test01(){
		//简单判断是否全部是数字，这个数字可以是1~n位
		String str = "12a345";
		
		//正则不是Java的语法，它是独立与Java的规则
		//在正则中\是表示转义，
		//同时在Java中\也是转义
		boolean flag = str.matches("\\d+");
		System.out.println(flag);
	}
	
	@Test
	public void test02(){
		String str = "123456789";
		
		//判断它是否全部由数字组成，并且第1位不能是0，长度为9位
		//第一位不能是0，那么数字[1-9]
		//接下来8位的数字，那么[0-9]{8}+
		boolean flag = str.matches("[1-9][0-9]{8}+");
		System.out.println(flag);
	}

替换相关

• String replace(xx,xx)：不支持正则
• String replaceFirst(正则，value)：替换第一个匹配部分
• String repalceAll(正则， value)：替换所有匹配部分

@Test
	public void test01(){
		String str = "hello244world.java;887";
		//把其中的非字母去掉
		str = str.replaceAll("[^a-zA-Z]", "");
		System.out.println(str);
	}

拆分相关

• String[] split(正则)：按照某种规则进行拆分

@Test
public void test1(){
	String str = "张三.23|李四.24|王五.25";
	// |在正则中是有特殊意义，我这里要把它当做普通的|
	String[] all = str.split("\\|");
	
	//输出结果
	for (int i = 0; i < all.length; i++) {
		System.out.println(all[i]);
	}
	
}

其他

• boolean isEmpty()：字符串是否为空
• int length()：返回字符串的长度
• String concat(xx)：拼接，等价于+
• boolean equals(Object obj)：比较字符串是否相等，区分大小写
• boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，区分大小写
• int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小
• int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写
• String toLowerCase()：将字符串中大写字母转为小写
• String toUpperCase()：将字符串中小写字母转为大写
• String trim()：去掉字符串前后空白符

代码示例

@Test
	public void test01(){
		//将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入
		Scanner input = new Scanner(System.in);
		String word;
		while(true){
			System.out.print("请输入单词：");
			word = input.nextLine();
			if(word.trim().length()!=0){
				word = word.toLowerCase();
				break;
			}
		}
		System.out.println(word);
	}

	@Test
	public void test02(){
        //随机生成验证码，验证码由0-9，A-Z,a-z的字符组成
		char[] array = new char[26*2+10];
		for (int i = 0; i < 10; i++) {
			array[i] = (char)('0' + i);
		}
		for (int i = 10,j=0; i < 10+26; i++,j++) {
			array[i] = (char)('A' + j);
		}
		for (int i = 10+26,j=0; i < array.length; i++,j++) {
			array[i] = (char)('a' + j);
		}
		String code = "";
		Random rand = new Random();
		for (int i = 0; i < 4; i++) {
			code += array[rand.nextInt(array.length)];
		}
		System.out.println("验证码：" + code);
		//将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入
		Scanner input = new Scanner(System.in);
		System.out.print("请输入验证码：");
		String inputCode = input.nextLine();
		
		if(!code.equalsIgnoreCase(inputCode)){
			System.out.println("验证码输入不正确");
		}
	}

可变字符序列

前面说到String字符串是不适合于大量改动的场景的，但是这种场景确实存在，针对这种问题，Java做了专门的类来应对，即java.lang包提供了可变字符序列StringBuilder和StringBuffer类型。

• StringBuffer：老的，线程安全的（因为它的方法有synchronized修饰（线程看后面的文章））
• StringBuilder：线程不安全的

其常用的方法介绍如下：

• append(xx)：拼接，追加
• insert(int index, xx)：插入
• delete(int start, int end)：删除
• deleteCharAt(int index)：删除指定位置
• reverse() : 反转

代码示例

	@Test
	public void test4(){
		StringBuilder s = new StringBuilder("helloworld");
		s.reverse();
		System.out.println(s);
	}
	
	@Test
	public void test3(){
		StringBuilder s = new StringBuilder("helloworld");
		s.delete(1, 3);
		s.deleteCharAt(4);
		System.out.println(s);
	}
	
	
	@Test
	public void test2(){
		StringBuilder s = new StringBuilder("helloworld");
		s.insert(5, "java");
		System.out.println(s);
	}
	
	@Test
	public void test1(){
		StringBuilder s = new StringBuilder();
		s.append("hello").append(true).append('a').append(12);
		System.out.println(s);
		System.out.println(s.length());
	}

时间日期

获取和利用时间是Java中必不可少的东西，毕竟我们无时无刻不在与时间打交道。根据JDK的不同，时间方法有些区别，这里以JDK1.8为界，分为JDK1.8之前，JDK1.8之后。

JDK1.8之前

在JDK1.8之前，Java自身提供的时间日期类并没有达到很好的效果，虽然日期常用，但是其开发人员大多使用第三方类库（ Joda-Time）。不过，我们还是要介绍下，因为JDK1.8之后就好用了，这也是为了完整性。

java.util.Date

java.util 包提供了 Date 类来封装当前的日期和时间。其常用方法如下：

• long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
• void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
• String toString( )把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

代码示例

 @Test
    public void test8(){
        // 初始化 Date 对象
        Date date = new Date();

        long time = date.getTime();
        date.setTime(200);

        // 使用 toString() 函数显示日期时间
        System.out.println(date.toString());
        System.out.println(time);
    }

java.util.Calendar

Calendar 类能设置和获取日期数据的特定部分，比如说小时，日，或者分钟? 又可以在日期的这些部分加上或者减去值。Calendar类是一个抽象类，其功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。

Calendar类对象的创建

在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

Calendar c = Calendar.getInstance();//默认是当前日期
c.set(2009, 6 - 1, 12); //指定日期

Calendar类对象字段类型

• Calendar.YEAR 年份
• Calendar.MONTH 月份
• Calendar.DATE 日期
• Calendar.DAY_OF_MONTH 日期，和上面的字段意义完全相同
• Calendar.HOUR 12小时制的小时
• Calendar.HOUR_OF_DAY 24小时制的小时
• Calendar.MINUTE 分钟
• Calendar.SECOND 秒
• Calendar.DAY_OF_WEEK 星期几

GregorianCalendar类

Calendar类实现了公历日历，GregorianCalendar是Calendar类的一个具体实现。Calendar 的getInstance（）方法返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。GregorianCalendar定义了两个字段：AD和BC。这是代表公历定义的两个时代。GregorianCalendar 类常用方法介绍如下：

• int get(int field) 获取指定字段的时间值
• Date getGregorianChange() 获得格里高利历的更改日期。
• Date getTime() 获取日历当前时间。
• long getTimeInMillis() 获取用长整型表示的日历的当前时间
• void set(int year, int month, int date) 设置年、月、日的值。
• void setGregorianChange(Date date) 设置 GregorianCalendar 的更改日期。
• void setTime(Date date)用给定的日期设置Calendar的当前时间。
• String toString() 返回代表日历的字符串。

代码示例

    @Test
    public void test7(){

        String months[] = {
                "Jan", "Feb", "Mar", "Apr",
                "May", "Jun", "Jul", "Aug",
                "Sep", "Oct", "Nov", "Dec"};
        // 初始化 Gregorian 日历
        // 使用当前时间和日期
        // 默认为本地时间和时区
        GregorianCalendar gcalendar = new GregorianCalendar();
        Date date = new Date();

        int i = gcalendar.get(1);
        Date time = gcalendar.getTime();
        long timeInMillis = gcalendar.getTimeInMillis();
        gcalendar.set(2022,1,06);
        gcalendar.setGregorianChange(date);
        gcalendar.setTime(date);
        String string = gcalendar.toString();

        System.out.println(i);
        System.out.println(time);
        System.out.println(timeInMillis);
        System.out.println(string);
        System.out.println(gcalendar);

    }

JDK1.8之后

JDK1.8是日期的极大改进，这之后其变得更好用了。其介绍如下：

LocalDate、LocalTime、LocalDateTime

• now()：获取系统日期或时间
• of(xxx)：或者指定的日期或时间
• 运算：运算后得到新对象，需要重新接受
  plusXxx()：在当前日期或时间对象上加xx
  minusXxx() ：在当前日期或时间对象上减xx
• getDayOfMonth()/getDayOfYear() 获得月份天数(1-31) /获得年份天数(1-366)
• getDayOfWeek() 获得星期几(返回一个 DayOfWeek 枚举值)
• getMonth() 获得月份, 返回一个 Month 枚举值
• getMonthValue() / getYear() 获得月份(1-12) /获得年份
• getHours()/getMinute()/getSecond() 获得当前对象对应的小时、分钟、秒
• withDayOfMonth()/withDayOfYear()/withMonth()/withYear() | 将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象 |
• isBefore()/isAfter() 比较两个 LocalDate
• format(DateTimeFormatter t) 格式化本地日期、时间，返回一个字符串
• parse(Charsequence text) 将指定格式的字符串解析为日期、时间

DateTimeFormatter

DateTimeFormatter是日期时间格式化。该类提供了三种格式化方法：

• 预定义的标准格式。如：ISO_DATE_TIME;ISO_DATE
• 本地化相关的格式。如：ofLocalizedDate(FormatStyle.MEDIUM)
• 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

代码示例

	@Test
	public void test10(){
		LocalDateTime now = LocalDateTime.now();
		
//		DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);//2019年6月6日 下午04时40分03秒
		DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);//19-6-6 下午4:40
		String str = df.format(now);
		System.out.println(str);
	}
	@Test
	public void test9(){
		LocalDateTime now = LocalDateTime.now();
		
		DateTimeFormatter df = DateTimeFormatter.ISO_DATE_TIME;//2019-06-06T16:38:23.756
		String str = df.format(now);
		System.out.println(str);
	}
	
	@Test
	public void test8(){
		LocalDateTime now = LocalDateTime.now();
		
		DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒  SSS毫秒  E 是这一年的D天");
		String str = df.format(now);
		System.out.println(str);
	}
	
	@Test
	public void test7(){
		LocalDate now = LocalDate.now();
		LocalDate before = now.minusDays(100);
		System.out.println(before);//2019-02-26
	}
	
	@Test
	public void test06(){
		LocalDate lai = LocalDate.of(2019, 5, 13);
		LocalDate go = lai.plusDays(160);
		System.out.println(go);//2019-10-20
	}
	
	@Test
	public void test05(){
		LocalDate lai = LocalDate.of(2019, 5, 13);
		System.out.println(lai.getDayOfYear());
	}
	
	
	@Test
	public void test04(){
		LocalDate lai = LocalDate.of(2019, 5, 13);
		System.out.println(lai);
	}
	
	@Test
	public void test03(){
		LocalDateTime now = LocalDateTime.now();
		System.out.println(now);
	}
	
	@Test
	public void test02(){
		LocalTime now = LocalTime.now();
		System.out.println(now);
	}
	
	@Test
	public void test01(){
		LocalDate now = LocalDate.now();
		System.out.println(now);
	}