2021-10-25 十一、常用类

最新推荐文章于 2022-07-25 17:51:59 发布

梦开始的地方丶

最新推荐文章于 2022-07-25 17:51:59 发布

阅读量627

点赞数

分类专栏： Java Java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_43901488/article/details/120954518

版权

Java基础同时被 2 个专栏收录

19 篇文章 1 订阅

订阅专栏

Java

15 篇文章 0 订阅

订阅专栏

常用类

1. String相关类
2. 日期时间API
3. 比较器
4. System类
5. Math类
6. BigInteger与BigDecimal
- 6.1 BigInteger
- 6.2 BigDecimal

1. String相关类

1.1 String类

1.1.1 概述

String：字符串，使用一对""引起来表示。

String声明为final的，不可被继承

final String val = "final";
val = "change"; // 错误 Cannot assign a value to final variable，因为final修饰的字符串不能指向新的地址

String实现了Serializable接口：表示字符串是支持序列化的（后面讲的时候IO流会讲到）。
实现了Comparable接口：表示String可以比较大小
String内部定义了final char[] value用于存储字符串数据

// String源码
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

String代表不可变的字符序列，简称不可变性。重点!!!
体现：
1. 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
3. 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
4. 通过字面量的方式（区别于new，new出来的String是存放在堆中的）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
5. 字符串常量池中是不会存储相同内容的字符串的。

示例

public class StringTest {
    @Test
    public void Test1(){
        String s1 = "abc";  //字面量的定义方式
        String s2 = "abc";
        System.out.println(s1 == s2);//比较s1和s2的地址值 true，因为都指向同一个常量池地址
        s1 = "hello";

        System.out.println(s1 == s2);//false s1会指向新的地址

        System.out.println(s1);//hello
        System.out.println(s2);//abc

        System.out.println("*********************");

        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        System.out.println(s2);//abc

        System.out.println("**********************");

        String s4 = "abc";
        String s5 = s4.replace('a', 'm');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
    }
}

地址解析

1.1.2 字面量赋值和构造器赋值的区别

问题： String str1 = “abc”;与String str2 = new String(“abc”);的区别？
字面量赋值只是在栈空间开辟了一个空间存放str1，然后在字符串常量池中存储了"abc"，栈空间直接指向字符串常量池
构造器赋值则是在堆空间开辟了一个对象，在栈空间存放了一个变量str2，该变量指向堆空间的对象，然后该对象指向了字符串常量池中对应的字符串
字符串常量存储在字符串常量池，目的是共享
字符串非常量对象存储在堆中。

示例

import org.junit.Test;

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class StringTest {
    @Test
    public void test2(){
        //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
        String s1 = "javaEE";
        String s2 = "javaEE";

        //通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false

        System.out.println("***********************");
        Person p1 = new Person("Tom",12);
        Person p2 = new Person("Tom",12);

        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name == p2.name);//true 这里相当于字面量赋值，只是name是在堆空间中指向常量池

        p1.name = "Jerry"; // 修改之后会开辟新的常量池地址，堆中的name会指向这个新的地址
        System.out.println(p2.name);//Tom
    }
}

内存解析

问题：String s = new String(“abc”);方式创建对象，在内存中创建了几个对象？
两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”

1.1.3 String不同实例化方式的对比

示例

String str = "abc"; // 字面量赋值会将其放入到常量池

//本质是this.value = new char[0];
String s1 = new String(); 

// 本质是在栈指向堆中对象，堆中对象指向字符串常量池对应的字符串
String s2 = new String("abc");
// 下面是源码里的构造器
//    public String(String original) {
//        this.value = original.value;
//        this.hash = original.hash;
//    }

//this.value = Arrays.copyOf(value, value.length);
char[] arr = {'a', 'b'};
String  s3 = new String(arr);

int startIndex = 0, count = 3;
String  s4 = new String(arr, startIndex, count);

在这里插入图片描述

1.1.4 String不同拼接操作的对比

结论

常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
只要其中有一个是变量，结果就在堆中
如果拼接的结果调用intern()方法，返回值就在常量池中

import org.junit.Test;

public class StringTest {

    @Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false 因为s5拼接的时候右边有变量，相当于new一个对象，所以s5指向的是堆地址。（JVM会自动创建一个StringBuilder然后再用append()方法最后再调用toString()方法返回）
        System.out.println(s3 == s6);//false
        System.out.println(s5 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false

        String s8 = s5.intern();//s5.intern()返回值得到的s8，使用的是常量池中的“javaEEhadoop”
        System.out.println(s3 == s8);//true
    }

    @Test
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false，因为s3拼接的时候右边有变量，相当于new一个对象，所以s3指向的是堆地址

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true

    }
	
	@Test
	public void test4_4() {
 	    String str1 = new StringBuilder("计算机").append("软件").toString();
        String str2 = str1.intern();
        String str3 = new StringBuilder("ja").append("va").toString();
        String str4 = str3.intern();
        System.out.println(str1==str2);
        System.out.println(str3==str4);
	}
}

知识拓展：String.intern();
作用：如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则直接返回常量池中该字符串的引用；
如果没有包含：

在jdk1.6中，Java的常量池是在方法区，因此将此String对象添加到常量池中，然后返回这个String对象的引用（也就是常量池的地址，此时引用的串在常量池）。两个都是false

在jdk1.7中，方法区的常量池被移到了堆中，会在常量池中放入一个引用，指向堆中的String对象的地址，返回这个引用地址（此时引用的串在堆）。第一个true，第二个是false

为什么java字符在编译期就已经在方法区的常量池中？

进入System类之后，我们发现这里有一个Version.init方法
进去看之后会发现很多常量被定义了，其中包括了java

练习

public class StringTest {
    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

解析：
ex.change(ex.str, ex.ch);ex.str虽然传入的是堆中的地址，但是change方法中str的修改不会影响到外面的str，只会把change方法中的str指向新的常量池地址（不可变性）
而ch字符数组没有这种不可变性，因此会被修改

1.1.4 JVM中涉及字符串的内存结构

这里建议JVM的时候再学，或者看视频过一下https://www.bilibili.com/video/BV1Kb411W75N?p=456

1.1.5 String的常用方法

Part1

方法	作用
`int length()`	返回字符串的长度：`return value.length`
`char charAt(int index)`	返回某索引处的字符`return value[index]`
`boolean isEmpty()`	判断是否是空字符串：`return value.length==0`
`String toLowerCase()`	使用默认语言环境，将String中的所有字符转换为小写
`String toUpperCase()`	使用默认语言环境，将String中的所有字符转换为大写
`String trim()`	返回字符串的副本，忽略前导空白和尾部空白
`boolean equals(Object obj)`	比较字符串的内容是否相同
`boolean equals IgnoreCase(String anotherString)`	与equals方法类似，忽略大小写
`String concat(String str)`	将指定字符串连接到此字符串的结尾。等价于用“+”
`int compareTo(String anotherString)`	比较两个字符串的大小
`String substring(int beginIndex)`	返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
`String substring(int beginIndex,int endIndex)`	返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

import org.junit.Test;

public class StringMethodTest {

    @Test
    public void Test1(){
        String s1 = "helloworld";
        System.out.println(s1.length()); // 10
        System.out.println(s1.charAt(0)); // h
        System.out.println(s1.charAt(9)); // d
//        System.out.println(s1.charAt(10)); 越界
//        s1 = "";
        //System.out.println(s1.isEmpty()); true

        String s2 = s1.toLowerCase();
        System.out.println(s1);//s1不可变的，仍然为原来的字符串
        System.out.println(s2);//改成小写以后的字符串

        String s3 = "   he  llo   world   ";
        String s4 = s3.trim();
        System.out.println("-----" + s3 + "-----");
        System.out.println("-----" + s4 + "-----"); // 打印出来的为s3掐头去尾(空格)之后的字符串
    }
    @Test
    public void test2(){
        String s1 = "HelloWorld";
        String s2 = "helloworld";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true
        
        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);//abcdef

        String s5 = "abc";
        String s6 = new String("abe");
        System.out.println(s5.compareTo(s6));//-2   //涉及到字符串的排序

        String s7 = "周围好吵啊";
        String s8 = s7.substring(2);
        System.out.println(s7); // 周围好吵啊
        System.out.println(s8); // 好吵啊

        String s9 = s7.substring(0, 2);
        System.out.println(s9); // 周围
    }
}

Part2

方法	作用
`boolean endsWith(String suffix)`	判断字符串是否以指定的后缀结束
`boolean startsWith(String prefix)`	判断字符串是否以指定的前缀开始
`boolean startsWith(String prefix, int toffset)`	判断字符串从指定索引开始的子字符串是否以指定前缀开始
`boolean contains(CharSequence s)`	字符串包含指定的 char 值序列时，返回 true
`int indexOf(String str)`	返回指定子字符串在字符串中第一次出现处的索引
`int indexOf(String str, int fromIndex)`	从指定的索引开始搜索，返回指定子字符串在字符串中第一次出现处的索引，
`int lastIndexOf(String str)`	返回指定子字符串在字符串中最右边出现处的索引
`int lastIndexOf(String str, int fromIndex)`	从指定的索引开始反向搜索，返回指定子字符串在此字符串中最后一次出现处的索引

注: lastIndexOf 和 indexOf未找到都返回-1

import org.junit.Test;

public class StringMethodTest {
    @Test
    public void test3(){
        String str1 = "helloworld";
        boolean b1 = str1.endsWith("rld");
        System.out.println(b1); //true

        boolean b2 = str1.startsWith("He");
        System.out.println(b2); // false

        boolean b3 = str1.startsWith("ll",2);
        System.out.println(b3); // true

        String str2 = "wor";
        System.out.println(str1.contains(str2)); // true
        System.out.println(str1.indexOf("lo")); // 3
        System.out.println(str1.indexOf("lo",5)); // -1 从指定下标开始往后找找不到，返回-1

        String str3 = "hellorworld";

        System.out.println(str3.lastIndexOf("or")); // 7
        System.out.println(str3.lastIndexOf("or",6)); // 4
    }
}

什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
情况一：存在唯一的一个str。
情况二：不存在str。

Part3

方法	作用
`String replace(char oldChar, char newChar)`	返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
`String replace(CharSequence target, CharSequence replacement)`	使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
`String replaceAll(String regex, String replacement)`	使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
`String replaceFirst(String regex, String replacement)`	使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
`boolean matches(String regex)`	告知此字符串是否匹配给定的正则表达式。
`String[] split(String regex)`	根据给定正则表达式的匹配拆分此字符串。
`String[] split(String regex, int limit)`	根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

import org.junit.Test;

public class StringMethodTest {
    @Test
    public void test4(){
        String str1 = "西藏布达拉宫欢迎您";
        String str2 = str1.replace('西','东');

        System.out.println(str1); // 西藏布达拉宫欢迎您
        System.out.println(str2); // 东藏布达拉宫欢迎您

        String str3 = str1.replace("北京", "南京");
        System.out.println(str3); // 西藏布达拉宫欢迎您  没有匹配字符，不替换

        System.out.println("*************************");
        String str = "12hello34world5java7891mysql456";
        //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
        String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
        System.out.println(string); // hello,world,java,mysql

        System.out.println("*************************");
        str = "12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches = str.matches("\\d+");
        System.out.println(matches); // true
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");
        System.out.println(result); // true

        System.out.println("*************************");
        str = "hello|world|java";
        String[] strs = str.split("\\|"); // 根据 | 来划分字符
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]); // 输出三个字符
        }
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }
    }
}

1.2 String与其他类的转换

1.2.1 String与基本数据类型包装类的转换

复习
String与基本数据类型、包装类之间的转换

String => 基本数据类型、包装类
调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类 => String
调用String重载的valueOf(xxx)

import org.junit.Test;

/**
 * 涉及到String类与其他结构之间的转换
 */
public class StringTest1 {

    @Test
    public void test1(){
        String str1 = "123";
//        int num = (int)str1;//错误的
        int num = Integer.parseInt(str1);

        String str2 = String.valueOf(num);   //"123"
        String str3 = num + "";

        System.out.println(str1 == str3);   //false str1是指向常量池，str3是指向堆地址
        System.out.println(str1 == str3.intern());   //true
        System.out.println(str2.intern() == str3.intern());   //true
    }
}

1.2.2 String与char[]之间的转换

String 与 char[]之间的转换

String => char[]
调用String的toCharArray()
char[] => String
调用String的构造器

import org.junit.Test;

/**
 * 涉及到String类与其他结构之间的转换
 */
public class StringTest1 {
    @Test
    public void test2(){        
    
    	String str1 = "abc123";

        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.print(charArray[i]+ " "); // a b c 1 2 3 
        }
        System.out.println();

        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2); // hello
    }
}

1.2.3 String与byte[]之间的转换

String 与 byte[]之间的转换

编码：String --> byte[]
调用String的getBytes()
本质：字符串 =>字节 (也就是从看得懂的字符串 =>看不懂的二进制数据)
解码：byte[] --> String
调用String的构造器
本质：编码的逆过程，字节 => 字符串（看不懂的二进制数据 => 看得懂的字符串）

说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
 * 涉及到String类与其他结构之间的转换
 */
public class StringTest1 {

    @Test
    public void test3() throws UnsupportedEncodingException {
        String str1 = "abc123重工";
        byte[] bytes = str1.getBytes();//使用默认的字符编码集,进行转换
        // [97, 98, 99, 49, 50, 51, -23, -121, -115, -27, -73, -91] 
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。
        // [97, 98, 99, 49, 50, 51, -42, -40, -71, -92]
        System.out.println(Arrays.toString(gbks));

        System.out.println("*****************************");

        String str2 = new String(bytes);//使用默认的字符集，进行解码。
        // abc123重工
        System.out.println(str2);

        String str3 = new String(gbks);
        System.out.println(str3);//出现乱码。原因：编码集和解码集不一致！

        String str4 = new String(gbks,"gbk");
        System.out.println(str4);//没有出现乱码。原因：编码集和解码集一致！
    }
}

1.3 String相关算法题

练习1：模拟一个trim方法，去除字符串两端的空格。
思路：
方法1：分别从头到尾、从尾到头循环遍历字符串，获取到第一个非空格字符的下标start、end，然后用substring方法截取字符串
方法2：正则表达式直接把空格替换掉

public class StringTestDemo {

    /**
     * 去除字符串两端的空格
     */
    private static void myTrim(String oldString) {
        // 用于正反向循环，记录下标位置
        int start = 0, end = oldString.length() - 1;
        // 正向循环
        while (start < oldString.length() && ' ' == oldString.charAt(start)) {
            start++;
        }
        // 如果start等于字符串长度说明整个字符串都是空格，直接返回
        if (start == oldString.length()) {
            System.out.println("字符串为空格");
            return;
        }
        // 反向循环
        while (end > start && ' ' == oldString.charAt(end)) {
            end--;
        }
        // 截取字符串
        String newString = oldString.substring(start, end + 1);
        System.out.println("-----" + newString + "-----");
    }
    
    public static void main(String[] args) {
        System.out.println("======去除字符串两端空格======");
        String oldString = "             ";
        myTrim(oldString); // 字符串为空格
        String oldString2 = "      143234214       ";
        myTrim(oldString2); // -----143234214-----
    }
}

练习2：将一个字符串中指定部分进行反转。
思路：
方法1：将String转成char[]，从指定的下标开始循环进行交换
方法2：将String根据指定下标截成三个部分，将第二部分进行逆序并拼接。
方法3：用StringBuilder或者StringBuffer来操作String（本质和char[]相似）

public class StringTestDemo{
    /**
     * 逆序指定下标的字符串
     */
    private static void reverseString(String oldString, Integer start, Integer end) {
        // 参数校验
        if (oldString == null || oldString.length() == 0) {
            System.out.println("字符串为空");
            return;
        }
        if (start < 0 || start > oldString.length() - 1) {
            System.out.println("开始索引位置不正确");
            return;
        }
        if (end < start || end > oldString.length() - 1) {
            System.out.println("结束索引位置不正确");
            return;
        }
        // ================== 方法1 char数组逆序 ===================
/*        final char[] chars = oldString.toCharArray();
        char temp;
        for (int i = start, j = end; i < j; i++, j--) {
            temp = chars[j];
            chars[j] = chars[i];
            chars[i] = temp;
        }
        System.out.println(new String(chars));*/

        // ================== 方法2 String切分逆序 ===================
        // 获取逆序部分前的数据
/*        String reverseString = oldString.substring(0, start);
        // 逆序加入
        for (int i = end; i >= start; i--) {
            reverseString += oldString.charAt(i);
        }
        // 加入逆序部分后的数据
        reverseString += oldString.substring(end);
        System.out.println(reverseString);*/

        // ================== 方法3 StringBuilder或者StringBuffer逆序 ===================
        
        final StringBuilder stringBuilder = new StringBuilder(oldString.length());
        // 获取逆序部分前的数据
        stringBuilder.append(oldString, 0, start);
        // 逆序加入
        for (int i = end; i >= start; i--) {
            stringBuilder.append(oldString.charAt(i));
        }
        // 加入逆序部分后的数据
        stringBuilder.append(oldString.substring(end));
        System.out.println(stringBuilder);
    }
    
    public static void main(String[] args) {

        System.out.println("======= 逆序指定下标字符串 ======");
        String oldString = "abcdefg";
        reverseString(oldString, 0, oldString.length() - 1); // gfedcba
        reverseString(oldString, 2, 5); // abfedcg
    }
}

练习3：获取一个字符串在另一个字符串中出现的次数
思路：
遍历字符串，使用indexof函数
（也可以自己实现indexof，匹配到第一个字符就匹配接下来的）

public class StringTestDemo{
    /**
     * 获取一个字符串在另一个字符串中出现的次数
     */
    private static void findIndexNum(String string, String key) {
        if (key == null || key.length() == 0 || string == null) {
            System.out.println("请输入正确的字符串");
            return;
        }
        final int keyLength = key.length();
        int index = 0;
        int count = 0;
        // 如果主字符串的长度小于key，就直接返回
        if (string.length() < keyLength) {
            System.out.println("无重复字符串");
            return;
        }
        // 方法一、使用indexof函数，指定下标开始搜索，如果匹配到就加上key的长度
/*        while ((index = string.indexOf(key,index)) != -1) {
            index+=keyLength;
            count++;
        }*/

        // 方法二、自己实现indexof
        final char first = key.charAt(0);
        // 用来判断是否完整的匹配上
        boolean flag = true;
        for (int i = 0; i <= string.length() - keyLength; i++) {
            final char c = string.charAt(i);
            // 匹配主字符串的当前字符和key的第一个字符，如果匹配得上就匹配下一个
            if (c == first) {
                for (int j = 1; j < keyLength; j++) {
                    // 如果后面的字符匹配不上就直接break
                    if (string.charAt(i + j) != key.charAt(j)) {
                        flag = false;
                        break;
                    }
                }
                // 如果flag是true，说明完整匹配上了，给i加上步长，并统计个数
                if (flag) {
                    count++;
                    i += (keyLength - 1);
                }
                // 重置flag
                flag = true;
            }
        }
        System.out.println("出现次数为：" + count);
    }  
    
    public static void main(String[] args) {

        System.out.println("======= 获取一个字符串在另一个字符串中出现的次数 ========");
        String string = "123321123321123321";
        String key = "123";
        findIndexNum(string, key);
    }
}

练习4：获取两个字符串中最大相同子串
思路，先辨别大串和小串。以大串为主串，缩小小串的范围来for循环匹配。

public class StringTestDemo{
    /**
     * 获取两个字符串中最大相同子串
     */
    private static void findMaxChildString(String str1, String str2) {
        if (str1 == null || str1.length() == 0 || str2 == null || str2.length() == 0) {
            System.out.println("无相同子串");
            return;
        }
        // 获取最大最小串
        String maxStr = str1.length() >= str2.length() ? str1 : str2;
        String minStr = str1.length() < str2.length() ? str1 : str2;
        int length = minStr.length();
        StringBuffer sBuffer = new StringBuffer();
		// for循环匹配
        for (int i = 0; i < length; i++) {
            for (int j = 0, k = length - i; k <= length; j++, k++) {
                final String subStr = str2.substring(j, k);
                // 匹配到就放入
                if (maxStr.contains(subStr)) {
                    sBuffer.append(subStr+",");
                }
            }
            // 如果已经添加进去，那么说明接下来没有比这个子串更大的了，直接跳出循环即可
            if (sBuffer.length() != 0) {
                break;
            }
        }
        String[] split = sBuffer.toString().replaceAll(",$", "").split(",");
        System.out.println(Arrays.toString(split));
    } 
    
    public static void main(String[] args) {
        System.out.println("======= 获取两个字符串中最大相同子串 ========");
        String str1 = "abcwerthello1yuiodefabcdef";
        String str2 = "cvhello1bnmabcdef";
        findMaxChildString(str1, str2);
    }

1.4 StringBuffer和StringBuilder

String、StringBuffer、StringBuilder三者的异同？

String:不可变的字符序列；底层使用char[]存储
StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

1.4.1 源码解析

这里比较简单，大家可以自己看源码昂…我就偷懒只写部分源码了

StringBuffer和StringBuilder都继承了AbstractStringBuilder类
调用空参构造器会默认创建一个长度为16的char数组
public StringBuilder() { super(16); }
public StringBuffer() { super(16); }
父类构造器
AbstractStringBuilder(int capacity) { value = new char[capacity]; }
调用public StringBuffer(String str)有参构造器则会创建一个参数长度+16的char数组；
调用public StringBuffer(int capacity)则是指定了数组的长度为capacity
注意capacity()和length()的区别，前者是返回数组的容量，后者是返回数组有效数据的长度
如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。
详情看父类中的private int newCapacity(int minCapacity)源码

import org.junit.Test;

/**
 * 关于StringBuffer和StringBuilder的使用
 */
public class StringBufferBuilderTest {

    @Test
    public void test1(){
    	String str = new String();//char[] value = new char[0];
    	String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};
    	StringBuffer sb10 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
    	System.out.println(sb10.length());//0
        System.out.println(sb10.capacity());//16
    	sb10.append('a');//value[0] = 'a';
     	sb10.append('b');//value[1] = 'b'; 如果没有到达capacity的话不会扩容
    	System.out.println(sb10.length());//3
        System.out.println(sb10.capacity());//16
        StringBuffer sb20 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];
        
        StringBuffer sb1 = new StringBuffer("abc");
        sb1.setCharAt(0,'m');
        System.out.println(sb1);

        StringBuffer sb2 = new StringBuffer();
        System.out.println(sb2.length());   //0
    }
}

开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

1.4.2 StringBuffer中的常用方法

StringBuilder相似，这里用StringBuffer举例

方法	作用
`StringBuffer append(xxx)`	提供了很多的append()方法，用于进行字符串拼接
`StringBuffer delete(int start,int end)`	删除指定位置的内容
`StringBuffer replace(int start, int end, String str)`	把[start,end)位置替换为str
`StringBuffer insert(int offset, xxx)`	在指定位置插入xxx
`StringBuffer reverse()`	把当前字符序列逆转
`public int indexOf(String str)`	在当前字符中寻找第一次出现的子串的下标
`public String substring(int start,int end)`	返回一个从start开始到end索引结束的左闭右开区间的子字符串
`public int length()`	获取有效数据的长度
`public char charAt(int n )`	获取指定下标的字符
`public void setCharAt(int n ,char ch)`	将指定下标的字符修改成特定字符

总结：

增：append(xxx)
删：delete(int start,int end)
改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
查：charAt(int n )
插：insert(int offset, xxx)
长度：length();
遍历：for() + charAt() / toString()

import org.junit.Test;

/**
 * 关于StringBuffer和StringBuilder的使用
 */
public class StringBufferBuilderTest {

    @Test
    public void test2(){
        StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append('1');
        System.out.println(s1);
//        s1.delete(2,4);
//        s1.replace(2,4,"hello");
//        s1.insert(2,false);
//        s1.reverse();
        String s2 = s1.substring(1,3);
        System.out.println(s1);
        System.out.println(s1.length());
        System.out.println(s2);
    }
}

1.4.3 String、StringBuffer、StringBuilder效率对比

先说结论：从高到低排列StringBuilder > StringBuffer > String

import org.junit.Test;

/**
 * 关于StringBuffer和StringBuilder的使用
 */
public class StringBufferBuilderTest {
    @Test
    public void test3(){
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        //开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));
    }
}

2. 日期时间API

2.1 JDK8之前

在这里插入图片描述

2.1.1 System类中获取时间戳的方法

public static long currentTimeMillis()返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
此方法适于计算时间差。
计算世界时间的主要标准有：

UTC(Coordinated Universal Time)
GMT(Greenwich Mean Time)
CST(Central Standard Time)

import org.junit.Test;

/**
 * JDK 8之前日期和时间的API测试
 */
public class DateTimeTest {

    //1.System类中的currentTimeMillis()
    @Test
    public void test1(){
        long time = System.currentTimeMillis();
        //返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
        //称为时间戳
        System.out.println(time);
    }
}

2.1.2 Date类的使用

java.util.Date类 —> 表示特定的瞬间，精确到毫秒
* |—java.sql.Date类精确到日

java.util.Date类两个构造器的使用

	// 构造器一: 创建一个对应当前时间的Date对象
    public Date() {
        this(System.currentTimeMillis());
    }
    // 构造器二：创建指定毫秒数的Date对象
    public Date(long date) {
        fastTime = date;
    }

java.util.Date两个方法的使用
toString():显示当前的年、月、日、时、分、秒
getTime():获取当前Date对象对应的毫秒数。（时间戳）

java.sql.Date对应着数据库中的日期类型的变量

import org.junit.Test;

import java.util.Date;

/**
 * JDK 8之前日期和时间的API测试
 */
public class DateTimeTest {
    @Test
    public void test2(){
        //构造器一：Date()：创建一个对应当前时间的Date对象
        Date date = new Date();
        System.out.println(date.toString());   //Thu Oct 28 19:22:35 CST 2021
        System.out.println(date.getTime());    //1635420155583

        //构造器二：创建指定毫秒数的Date对象
        Date date2 = new Date(1635420155583L);
        System.out.println(date2.toString()); // Thu Oct 28 19:22:35 CST 2021

        //创建java.sql.Date对象，只确定到日
        java.sql.Date date3 = new java.sql.Date(35235325345L);
        System.out.println(date3);  //1971-02-13

        //如何将java.util.Date对象转换为java.sql.Date对象
        //情况一：
        Date date4 = new java.sql.Date(2343243242323L); 
        java.sql.Date date5 = (java.sql.Date) date4; 
        System.out.println(date4); // 2044-04-03
        System.out.println(date5); // 2044-04-03
        //情况二：
        java.sql.Date date7 = new java.sql.Date(date.getTime());
        System.out.println(date7); // 2021-10-28
    }
}

2.1.3 SimpleDateFormat的使用

前面提到的Date类的API不易于国际化，大部分被废弃了java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。
作用：

格式化：日期—>文本
解析：文本—>日期

import org.junit.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * jdk 8 之前的日期时间的API测试
 */
public class DateTime {
    @Test
    public void testSimpleDateFormat() throws ParseException {
        //实例化SimpleDateFormat
        SimpleDateFormat sdf = new SimpleDateFormat();

        //格式化：日期---》字符串
        Date date = new Date();
        System.out.println(date);   //Thu Oct 28 19:25:30 CST 2021

        String format = sdf.format(date);
        System.out.println(format); //21-10-28 下午07:25

        //解析：格式化的逆过程，字符串---》日期
        String str = "21-10-28 下午07:25";
        Date date1 = sdf.parse(str);
        System.out.println(date1);  //Thu Oct 28 19:25:00 CST 2021

        //*************按照指定的方式格式化和解析：调用带参的构造器*****************
//        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss aa"); // 正常情况下会用这样的形式
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMM.dd GG hh:mm aa");
        //格式化
        String format1 = sdf1.format(date);
        System.out.println(format1);    //02021.十月.28 公元 07:27 下午
        //解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),否则抛异常
        Date date2 = sdf1.parse("02021.十月.28 公元 07:27 下午");
        System.out.println(date2);  //Thu Oct 28 19:27:00 CST 2021
    }
}

练习1

import org.junit.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTime {

    /**
     * 练习1：字符串"2020-09-08"转换为java.sql.Date
     *
     */
    @Test
    public void testExer() throws ParseException {

        String birth = "2021-10-28";

        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf1.parse(birth);
        System.out.println(date); // Thu Oct 28 00:00:00 CST 2021

        java.sql.Date birthDate = new java.sql.Date(date.getTime());
        System.out.println(birthDate); // 2021-10-28
    }
}

2.1.4 Calendar日历类的使用

基本介绍：
Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。

获取实例的方式：
使用Calendar.getInstance()方法
调用它子类GregorianCalendar的构造器。

一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。具体的field可以使用Calendar中定义的相关常量，例如：calendar.get(Calendar.DAY_OF_MONTH);

常用方法	作用
`public int get(int field)`	获取时间
`public void set(int field, int value)`	设置时间（月份下标从0开始，星期是从周日（1）开始）
`public void add(int field, int amount)`	时间计算
`public final Date getTime()`	根据时间戳获取当前时间
`public final void setTime(Date date)`	根据时间戳设置当前时间

import java.util.Calendar;
import java.util.Date;

import org.junit.Test;

public class DateTime {

    /**
     * Calendar日历类的使用
     */
    @Test
    public void testCalendar(){
        //1.实例化
        //方式一：创建其子类（GregorianCalendar）的对象
        //方式二：调用其静态方法getInstance()
        Calendar calendar = Calendar.getInstance();

//        System.out.println(calendar.getClass());    //class java.util.GregorianCalendar

        //2.常用方法
        //get()
        int days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);   //28
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR)); //301,今天是这一年的301天

        //set()
        //calendar可变性
        calendar.set(Calendar.DAY_OF_MONTH,22);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);   //22

        //add()
        calendar.add(Calendar.DAY_OF_MONTH,-3);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);   //22-3 --》19

        //getTime():日历类---> Date
        Date date = calendar.getTime();
        System.out.println(date);   //Tue May 19 17:12:06 CST 2020

        //setTime():Date ---> 日历类
        Date date1 = new Date();
        calendar.setTime(date1);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);   //28
    }
}

2.2 JDK8

新日期时间API出现的背景
如果我们可以跟别人说：“我们在1502643933071见面，别晚了！”那么就再简单不过了。但是我们希望时间与昼夜和四季有关，于是事情就变复杂了。JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：

可变性：像日期和时间这样的类应该是不可变的。
偏移性：Date中的年份是从1900开始的，而月份都从0开始。
格式化：格式化只对Date有用，Calendar则不行。
此外，它们也不是线程安全的；不能处理闰秒等。

import org.junit.Test;
import java.util.Date;

public class JDK8DateTimeTest {

    @Test
    public void testDate(){
        //年份和月份存在偏移量
        Date date1 = new Date(2020,9,8);
        System.out.println(date1);  //Fri Oct 08 00:00:00 CST 3920 
		// 需要输入如下的数据才能得到想得到的2020-9-8
        Date date2 = new Date(2020 - 1900,9 - 1,8);
        System.out.println(date2); //Tue Sep 08 00:00:00 CST 2020
    }
}

Java 8中引入的java.time API已经纠正了过去的缺陷
Java 8 吸收了Joda-Time 的精华，以一个新的开始为Java 创建优秀的API。新的java.time 中包含了所有关于本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。历史悠久的Date 类新增了toInstant()方法，用于把Date 转换成新的表示形式。这些新增的本地化时间日期API 大大简化了日期时间和本地化的管理。

java.time–包含值对象的基础包
* —|java.time.chrono–提供对不同的日历系统的访问
* —|java.time.format–格式化和解析时间和日期
* —|java.time.temporal–包括底层框架和扩展特性
* —|java.time.zone–包含时区支持的类
说明：大多数开发者只会用到基础包和format包，也可能会用到temporal包。因此，尽管有68个新的公开类型，大多数开发者，大概将只会用到其中的三分之一。

2.2.1 LocalDate、LocalTime、LocalDateTime的使用

LocalDate、LocalTime、LocalDateTime类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

LocalDate代表ISO格式（yyyy-MM-dd）的日期,可以存储生日、纪念日等日期。
LocalTime表示一个时间，而不是日期。
LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。

注：ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法，也就是公历。

在这里插入图片描述

import org.junit.Test;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class JDK8DateTimeTest {
    @Test
    public void test1(){
        // XXX.now():获取当前的日期、时间、日期+时间
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println(localDate); // 2021-10-28
        System.out.println(localTime); // 19:50:28.979
        System.out.println(localDateTime); // 2021-10-28T19:50:28.979

        //XXX.of():设置指定的年、月、日、时、分、秒。没有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
        System.out.println(localDateTime1); // 2020-10-06T13:23:43

        //XXX.getXxx()：获取相关的属性
        System.out.println(localDateTime.getDayOfMonth()); // 28
        System.out.println(localDateTime.getDayOfWeek()); // THURSDAY
        System.out.println(localDateTime.getMonth()); // OCTOBER
        System.out.println(localDateTime.getMonthValue()); // 10
        System.out.println(localDateTime.getMinute()); // 50

        //体现不可变性，原先的不会改变，会生成新的对象
        //withXxx():设置相关的属性
        LocalDate localDate1 = localDate.withDayOfMonth(22);
        System.out.println(localDate); // 2021-10-28
        System.out.println(localDate1); // 2021-10-22

        LocalDateTime localDateTime2 = localDateTime.withHour(4);
        System.out.println(localDateTime); // 2021-10-28T19:50:28.979
        System.out.println(localDateTime2); // 2021-10-28T04:50:28.979

        //不可变性 plusMonths() 加上月份
        LocalDateTime localDateTime3 = localDateTime.plusMonths(3); // 2021-10-28T19:50:28.979
        System.out.println(localDateTime); // 2021-10-28T19:50:28.979
        System.out.println(localDateTime3); // 2022-01-28T19:50:28.979

        // 减去天数
        LocalDateTime localDateTime4 = localDateTime.minusDays(6);
        System.out.println(localDateTime); // 2021-10-28T19:50:28.979
        System.out.println(localDateTime4);  // 2021-10-22T19:50:28.979
    }
}

2.2.2 Instant类的使用

基本介绍：时间线上的一个瞬时点。这可能被用来记录应用程序中的事件时间戳。
在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位。

java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。
单位换算：(1 ns = 10^9s)
1秒= 1000毫秒=10^6微秒 = 10^9纳秒

在这里插入图片描述

注意：时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。

import org.junit.Test;

import java.time.*;

public class JDK8DateTimeTest {

    @Test
    public void test2(){
        //now():获取本初子午线对应的标准时间
        Instant instant = Instant.now();
        System.out.println(instant);    //2021-10-28T12:03:11.210+08:00

        //添加时间的偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));//东八区
        System.out.println(offsetDateTime); //2021-10-28T20:03:11.210+08:00

        //toEpochMilli():获取自1970年1月1日0时0分0秒（UTC）开始的毫秒数  ---> 相当于 Date类的getTime()
        long milli = instant.toEpochMilli();
        System.out.println(milli);  //1635422591919

        //ofEpochMilli():通过给定的毫秒数，获取Instant实例  --> 相当于 Date(long millis)
        Instant instant1 = Instant.ofEpochMilli(1635422591919L);
        System.out.println(instant1);   //2021-10-28T12:03:11.919Z
    }
}

2.2.3 DateTimeFormatter的使用

用于格式化时间数据
预定义的标准格式。如：ISO_LOCAL_DATE_TIME、ISO_LOCAL_DATE、ISO_LOCAL_TIME
本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

在这里插入图片描述

import org.junit.Test;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;


public class JDK8DateTimeTest {

    @Test
    public void test3(){
        //方式一：预定义的标准格式。如：ISO_LOCAL_DATE_TIME; 日期+时间 可以看一下源码，就是下面两个和T拼接起来
        // ISO_LOCAL_DATE; 时间
        // ISO_LOCAL_TIME 日期
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //格式化:日期-->字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        String str1 = formatter.format(localDateTime);
        System.out.println(localDateTime);//2021-10-28T20:11:23.870
        System.out.println(str1);//2021-10-28T20:11:23.870

        //解析：字符串 -->日期
        TemporalAccessor parse = formatter.parse("2021-10-28T20:11:23.870");
        System.out.println(parse);// {},ISO resolved to 2021-10-28T20:11:23.870

        //方式二：
        //本地化相关的格式。如：ofLocalizedDateTime()
        //FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime 三种返回的格式不一样，具体可以自己玩一下或者直接看源码
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        //格式化
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);//2021年10月28日 下午08时12分36秒

        //本地化相关的格式。如：ofLocalizedDate()
        //FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
        //格式化
        String str3 = formatter2.format(LocalDate.now());
        System.out.println(str3);//2021-10-28


        //重点： 方式三：自定义的格式。如：ofPattern("yyyy-MM-dd HH:mm:ss")
        DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //格式化
        String str4 = formatter3.format(LocalDateTime.now());
        System.out.println(str4);//2021-10-28 20:15:50

        //解析
        TemporalAccessor accessor = formatter3.parse("2021-10-28 20:15:50");
        System.out.println(accessor); // {},ISO resolved to 2021-10-28T20:15:50
    }
}

2.2.4 其它日期时间相关API的使用

ZoneId：该类中包含了所有的时区信息，一个时区的ID，如Europe/Paris
ZonedDateTime：一个在ISO-8601日历系统时区的日期时间，如2007-12-03T10:15:30+01:00Europe/Paris。
其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如：Asia/Shanghai等

import org.junit.Test;

import java.time.*;
import java.util.Set;

/**
 * jdk 8中日期时间API的测试
 */
public class JDK8DateTimeTest {
	
	@Test
	public void test1(){
		//ZoneId:类中包含了所有的时区信息
		// ZoneId的getAvailableZoneIds():获取所有的ZoneId
		Set<String> zoneIds= ZoneId.getAvailableZoneIds();
		for(String s: zoneIds) {
			System.out.println(s);
		}
		// ZoneId的of():获取指定时区的时间
		LocalDateTime localDateTime= LocalDateTime.now(ZoneId.of("Asia/Tokyo"));
		System.out.println(localDateTime);
		
		//ZonedDateTime:带时区的日期时间
		// ZonedDateTime的now():获取本时区的ZonedDateTime对象
		ZonedDateTime zonedDateTime= ZonedDateTime.now();
		System.out.println(zonedDateTime);
		// ZonedDateTime的now(ZoneId id):获取指定时区的ZonedDateTime对象
		ZonedDateTime zonedDateTime1= ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
		System.out.println(zonedDateTime1);
	}
}

Clock：使用时区提供对当前即时、日期和时间的访问的时钟。
持续时间：Duration，用于计算两个“时间”间隔
日期间隔：Period，用于计算两个“日期”间隔
TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作。
TemporalAdjusters : 该类通过静态方法(firstDayOfXxx()/lastDayOfXxx()/nextXxx())提供了大量的常用TemporalAdjuster 的实现。

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.LocalTime;

import org.junit.Test;

public class JDK8APITest {
	
	@Test
	public void test2(){
		//Duration:用于计算两个“时间”间隔，以秒和纳秒为基准
		LocalTime localTime= LocalTime.now();
		LocalTime localTime1= LocalTime.of(15, 23, 32);
		//between():静态方法，返回Duration对象，表示两个时间的间隔
		Duration duration= Duration.between(localTime1, localTime);
		System.out.println(duration);
		
		System.out.println(duration.getSeconds());
		System.out.println(duration.getNano());
		
		LocalDateTime localDateTime= LocalDateTime.of(2016, 6, 12, 15, 23, 32);
		LocalDateTime localDateTime1= LocalDateTime.of(2017, 6, 12, 15, 23, 32);
		
		Duration duration1= Duration.between(localDateTime1, localDateTime);
		System.out.println(duration1.toDays());
	}

	
	@Test
	public void test3(){
		//Period:用于计算两个“日期”间隔，以年、月、日衡量
		LocalDate localDate= LocalDate.now();
		LocalDate localDate1= LocalDate.of(2028, 3, 18);
		
		Period period= Period.between(localDate, localDate1);
		System.out.println(period);
        System.out.println(period.getYears());
		
		System.out.println(period.getMonths());
		System.out.println(period.getDays());
		
		Period period1= period.withYears(2);
		System.out.println(period1); // 会把年的间隔变成Y2
	}
}

新旧API参考

3. 比较器

3.1 基本介绍

Java中的对象，正常情况下，只能通过==或!= 进行比较。不能使用 >或<的，但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
如何实现？
java提供了两个接口

自然排序：java.lang.Comparable
定制排序：java.util.Comparator

3.2 Comparable（自然排序）

1.String、包装(Wrapper)类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式,进行了从小到大的排列
2. 重写compareTo(obj)的规则：

如果当前对象this大于形参对象obj，则返回正整数，
如果当前对象this小于形参对象obj，则返回负整数，
如果当前对象this等于形参对象obj，则返回零。

示例

import org.junit.Test;
import java.util.Arrays;

public class CompareTest {
    @Test
    public void test1(){
        String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};

		// 详情可以查看String的compareTo方法
        Arrays.sort(arr);

		// [AA, CC, DD, GG, JJ, KK, MM]
        System.out.println(Arrays.toString(arr));
    }

}

3.2.1 自定义类实现Comparable自然排序

对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法。在compareTo(obj)方法中指明如何排序。

/**
 * 商品类
 */
public class Goods implements Comparable{

    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

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

    //指明商品比较大小的方式:按照价格从低到高排序,再按照产品名称从高到低排序
    @Override
    public int compareTo(Object o) {
//        System.out.println("**************");
        if(o instanceof Goods){
            Goods goods = (Goods)o;
            //比较价格方式一：
            if(this.price > goods.price){
                return 1;
            }else if(this.price < goods.price){
                return -1;
            }else{
				// 默认是从低到高，所以返回-XX就代表从高到低
                return -this.name.compareTo(goods.name);
            }
            //比较价格方式二：
//           return Double.compare(this.price,goods.price);
        }
        throw new RuntimeException("传入的数据类型不一致！");
    }
}

import org.junit.Test;
import java.util.Arrays;

public class CompareTest {
    @Test
    public void test2(){
        Goods[] arr = new Goods[5];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("microsoftMouse",43);

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));
    }

}

3.3 Comparator（定制排序）

3.3.1 使用背景

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序
使用方式：
重写compare(Object o1,Object o2)方法，比较o1和o2的大小：

如果方法返回正整数，则表示o1大于o2；
如果返回0，表示相等；
返回负整数，表示o1小于o2。

示例

import org.junit.Test;
import java.util.Arrays;
import java.util.Comparator;


public class CompareTest {

    @Test
    public void test3(){
        String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
        Arrays.sort(arr,new Comparator(){

            //按照字符串从大到小的顺序排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof String && o2 instanceof  String){
                    String s1 = (String) o1;
                    String s2 = (String) o2;
                    return -s1.compareTo(s2);
                }
                throw new RuntimeException("输入的数据类型不一致");
            }
        });
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void test4(){
        Goods[] arr = new Goods[6];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("huaweiMouse",224);
        arr[5] = new Goods("microsoftMouse",43);

        Arrays.sort(arr, new Comparator() {
            //指明商品比较大小的方式:按照产品名称从低到高排序,再按照价格从高到低排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Goods && o2 instanceof Goods){
                    Goods g1 = (Goods)o1;
                    Goods g2 = (Goods)o2;
                    if(g1.getName().equals(g2.getName())){
                        return -Double.compare(g1.getPrice(),g2.getPrice());
                    }else{
                        return g1.getName().compareTo(g2.getName());
                    }
                }
                throw new RuntimeException("输入的数据类型不一致");
            }
        });

        System.out.println(Arrays.toString(arr));
    }

Comparable接口与Comparator的使用的对比：

Comparable接口的方式一旦确定，那么Comparable接口实现类的对象在任何位置都可以比较大小。
Comparator接口则是属于临时性的比较。

4. System类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。例如

成员变量：

in 标准输入流(键盘输入)，如System.in.read();
out 标准输出流(显示器)，如System.out.println();
err 标准错误输出流(显示器)，如System.err.println();

成员方法

native long currentTimeMillis();：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
void exit(int status);：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
void gc();：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
getProperty(String key);该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：

import org.junit.Test;

public class OtherClassTest {

    @Test
    public void test1() {
        String javaVersion = System.getProperty("java.version");
        System.out.println("java的version:" + javaVersion);

        String javaHome = System.getProperty("java.home");
        System.out.println("java的home:" + javaHome);

        String osName = System.getProperty("os.name");
        System.out.println("os的name:" + osName);

        String osVersion = System.getProperty("os.version");
        System.out.println("os的version:" + osVersion);

        String userName = System.getProperty("user.name");
        System.out.println("user的name:" + userName);

        String userHome = System.getProperty("user.home");
        System.out.println("user的home:" + userHome);

        String userDir = System.getProperty("user.dir");
        System.out.println("user的dir:" + userDir);

    }
}

5. Math类

java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。
下面给出几个常用的，其他的自己百度搜一下用法吧

方法	作用
`public static long abs(long a)`	获取当前值的绝对值
`public static double sqrt(double a)`	计算当前数的算数平方根
`pow(double a,doble b)`	计算a的b次幂
`public static double log(double a)`	以e为底的对数值
`public static double exp(double a)`	以e为底的指数值
`max(double a,double b)`	求两个数的最小数
`min(double a,double b)`	求两个数的最大数
`public static double random()`	返回[0,1)的随机数
`public static long round(double a)`	将数据四舍五入的转换为long型

6. BigInteger与BigDecimal

6.1 BigInteger

Integer类作为int的包装类，能存储的最大整型值为2^31 -1，Long类也是有限的，最大为2^63 -1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger提供所有Java 的基本整数操作符的对应物，并提供java.lang.Math的所有相关方法。另外，BigInteger还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。
使用方式：
new BigInteger(String val);：根据字符串构建BigInteger对象

常用方法

6.2 BigDecimal

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。
BigDecimal类支持不可变的、任意精度的有符号十进制定点数。
使用方式：

new BigDecimal(double val);
new BigDecimal(String val);（通常建议优先使用String构造方法）

常用方法	作用
`public BigDecimal add(BigDecimal augend)`	返回（this+augend）的值
`public BigDecimal subtract(BigDecimal subtrahend)`	返回（this-subtrahend）的值
`public BigDecimal multiply(BigDecimal multiplicand)`	返回（this*multiplicand）的值
`public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)`	返回（this*multiplicand）的值，scale设置小数点位数，roundingMode设置舍入模式

import org.junit.Test;

import java.math.BigDecimal;
import java.math.BigInteger;

public class OtherClassTest {

    @Test
    public void test2() {
        BigInteger bi = new BigInteger("1243324112234324324325235245346567657653");
        BigDecimal bd = new BigDecimal("12435.351");
        BigDecimal bd2 = new BigDecimal("11");
        System.out.println(bi);
//         System.out.println(bd.divide(bd2));
        System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
        System.out.println(bd.divide(bd2, 25, BigDecimal.ROUND_HALF_UP));

    }
}

除法的八种舍入模式

ROUND_UP：舍入远离零的舍入模式。在丢弃非零部分之前始终增加数字(始终对非零舍弃部分前面的数字加1)。
注意，此舍入模式始终不会减少计算值的大小。
1130.4864 => 1130.487
ROUND_DOWN：接近零的舍入模式。在丢弃某部分之前始终不增加数字(从不对舍弃部分前面的数字加1，即截短)。
注意，此舍入模式始终不会增加计算值的大小。
1130.4864 => 1130.486
ROUND_CEILING：接近正无穷大的舍入模式。
如果 BigDecimal 为正，则舍入行为与 ROUND_UP 相同;
如果 BigDecimal 为负，则舍入行为与 ROUND_DOWN 相同。
注意，此舍入模式始终不会减少计算值。
ROUND_FLOOR：接近负无穷大的舍入模式。
如果 BigDecimal 为正，则舍入行为与 ROUND_DOWN 相同;
如果 BigDecimal 为负，则舍入行为与 ROUND_UP 相同。
注意，此舍入模式始终不会增加计算值。
ROUND_HALF_UP：向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。
如果舍弃部分 >= 0.5，则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同。
注意，这是我们大多数人在小学时就学过的舍入模式(四舍五入)。
ROUND_HALF_DOWN：向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为上舍入的舍入模式。
如果舍弃部分 > 0.5，则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同(五舍六入)。
ROUND_HALF_EVEN：向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。
如果舍弃部分左边的数字为奇数，则舍入行为与ROUND_HALF_UP相同(四舍五入);
如果舍弃部分左边的数字为偶数，则舍入行为与ROUND_HALF_DOWN 相同(五舍六入)。
注意，在重复进行一系列计算时，此舍入模式可以将累加错误减到最小。
此舍入模式也称为“银行家舍入法”，主要在美国使用。四舍六入，五分两种情况。如果前一位为奇数，则入位，否则舍去。
以下例子为保留小数点1位，那么这种舍入方式下的结果。
1.15=>1.2 1.25=>1.2
ROUND_UNNECESSARY：断言请求的操作具有精确的结果，因此不需要舍入。如果对获得精确结果的操作指定此舍入模式，则抛出ArithmeticException。