Java常用工具類(lèi)匯總附示例代碼

更新時(shí)間：2021年06月25日 17:31:20 作者：咕嚕辰

這篇文章主要介紹了Java常用工具類(lèi)，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著我來(lái)一起學(xué)習(xí)學(xué)習(xí)吧，希望能給你帶來(lái)幫助

Java常用類(lèi)

String類(lèi)

概述
String類(lèi)：代表字符串。Java程序中的所有字符串字面值（如：”abc“）都作為子類(lèi)的實(shí)例實(shí)現(xiàn)
String是一個(gè)final類(lèi)，代表不可變的字符序列
字符串是常量，用雙引號(hào)引起來(lái)表示。他們的值在創(chuàng)建之后不能更改
String對(duì)象的字符內(nèi)容是存儲(chǔ)在一個(gè)字符數(shù)組value[]中的

public final class String
    implements java.io.Serializable,Comparable<String>,CharSequence{
    /** The value is used for character storage*/
    private final char value[]; //String 的底層就是放在char型數(shù)組當(dāng)中（字符構(gòu)成的串） //final：value是引用類(lèi)型 其指向的地址不可以被修改
    /*Cache the hash code for the string*/
    private int hash; //Default to 0
}

    /*
    String:字符串：使用一對(duì)“”引起來(lái)表示
    1. String聲明為final的，不可被繼承
    2. String
        實(shí)現(xiàn)了Serializable接口：表示字符串是可序列化的
    （對(duì)象默認(rèn)不可以通過(guò)網(wǎng)絡(luò)傳輸，但是如果是可序列化的，那么就可以通過(guò)網(wǎng)絡(luò)傳輸給對(duì)方 IO流部分知識(shí)）
        實(shí)現(xiàn)了Comparable接口，表示String是可以比較大小的
    3. String在內(nèi)部定義了final的char型數(shù)組:final char value[] value用與存儲(chǔ)字符串?dāng)?shù)據(jù)
    4. 通過(guò)字面量的方式（區(qū)別于new）給一個(gè)字符串賦值，此時(shí)的字符串值聲明在字符串常量池中
    5. 字符串常量池中是不會(huì)存儲(chǔ)相同內(nèi)容的字符串的
     */

String不可變性
說(shuō)明以及代碼

/*4. final：數(shù)組引用變量不能在指向別的數(shù)組，且數(shù)組對(duì)象內(nèi)的元素也不能改變
      即const int* const p; p是常量指針，且不能通過(guò)p對(duì)所指向的變量進(jìn)行修改
    體現(xiàn)
        1）當(dāng)對(duì)字符串重新賦值是，需要重寫(xiě)指定內(nèi)存區(qū)域賦值，不能使用原有的value進(jìn)行賦值
        2) 當(dāng)對(duì)現(xiàn)有的字符串進(jìn)行連接操作時(shí)，也需要重新制定內(nèi)存區(qū)域賦值，不能使用原有的字符串*/

   @Test
    public void test(){
        String s1 = "abc";//字面量的定義方式
        String s2 = "abc";
        System.out.println(s1==s2);//true
        //        s1="hello";
        String s3 = "abc";
        s3+="def";//并沒(méi)有改變“abc” 而是新造了一個(gè)
        System.out.println(s3); //abcdef  并沒(méi)有改變“abc” 而是新造了一個(gè)
        System.out.println(s2);//abc
        System.out.println("******************");
        String s4 = "abc";
        String s5 = s4.replace('a','z');
        System.out.println(s5);
        System.out.println(s4);
        System.out.println(s2);
    }

//String 實(shí)例化的方式
  //  方式一：通過(guò)字面量定義的方式
  //  方式二：通過(guò)new+構(gòu)造器的方式

   @Test
    public void test2(){
        //通過(guò)字面量的方式 這個(gè)abc聲明在方法區(qū)的字符串常量池種
        String s1 = "abc";
        String s2 = "abc";
        //通過(guò)new+構(gòu)造器的方式：此時(shí)的s3,s4保存的地址值，是數(shù)據(jù)在堆空間中開(kāi)辟空間以后堆空間中地址值
        String s3 = new String("abc");
        String s4 = new String("abc");
        System.out.println(s1==s2); //true
        System.out.println(s1==s3); //false
        System.out.println(s3==s2); //false
        System.out.println("********************");
        Person p1 = new Person("shc");
        Person p2 = new Person("shc");
        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name==p2.name);//true 因?yàn)樵赑erson的對(duì)象中，生成String字符串的方式也是通過(guò)字面量 this.name="shc"
        //如果在Peron的構(gòu)造器中用this.name=new String("shc"); 的方式，那么就是false
    }

面試題：

面試題：!!!?？?String s = new String("abc"); 方式創(chuàng)建對(duì)象，在內(nèi)存中創(chuàng)建了幾個(gè)對(duì)象兩個(gè)：一個(gè)是堆空間中new結(jié)構(gòu)，另一個(gè)是char[]對(duì)應(yīng)的常量池中的數(shù)據(jù)："abc";

字符串拼接方式的對(duì)比

   /*
    1. 常量與與常量的拼接結(jié)果在常量池中，且常量池中不會(huì)存在相同內(nèi)容的常量
    2. 只要其中有一個(gè)是變量，結(jié)果就在堆中
    3. 如果拼接的結(jié)果調(diào)用intern()方法，返回值就在常量池中
     */

    @Test
    public void test3(){
        String s1 = "abc";
        String s2 = "hhh";
        String s3 = "abchhh"; //字面量
        String s4 = "abc"+"hhh"; //兩個(gè)字面量的連接 還是字面量 在常量池中
        String s5 = s1+"hhh";
        String s6 = "abc" + s2;
        String s7 = s1+s2;
        System.out.println(s3==s4); //true
        System.out.println(s3==s5); //false
        System.out.println(s3==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 s = s5.intern();
        System.out.println(s==s3);//true
    }

String用方法

/**
 *  int length()：返回字符串的長(zhǎng)度： return value.length
 *  char charAt(int index)： 返回某索引處的字符return value[index]
 *  boolean isEmpty()：判斷是否是空字符串：return value.length == 0
 *  String toLowerCase()：使用默認(rèn)語(yǔ)言環(huán)境，將 String 中的所有字符轉(zhuǎn)換為小寫(xiě)
 *  String toUpperCase()：使用默認(rèn)語(yǔ)言環(huán)境，將 String 中的所有字符轉(zhuǎn)換為大寫(xiě)
 *  String trim()：返回字符串的副本，忽略前導(dǎo)空白和尾部空白
 *  boolean equals(Object obj)：比較字符串的內(nèi)容是否相同
 *  boolean equalsIgnoreCase(String anotherString)：與equals方法類(lèi)似，忽略大小寫(xiě)
 *  String concat(String str)：將指定字符串連接到此字符串的結(jié)尾。 等價(jià)于用“+”
 *  int compareTo(String anotherString)：比較兩個(gè)字符串的大小
 *  String substring(int beginIndex)：返回一個(gè)新的字符串，它是此字符串的從
 * beginIndex開(kāi)始截取到最后的一個(gè)子字符串。
 *  String substring(int beginIndex, int endIndex) ：返回一個(gè)新字符串，它是此字
 * 符串從beginIndex開(kāi)始截取到endIndex(不包含)的一個(gè)子字符串。
 *
 *  boolean endsWith(String suffix)：測(cè)試此字符串是否以指定的后綴結(jié)束
 *  boolean startsWith(String prefix)：測(cè)試此字符串是否以指定的前綴開(kāi)始
 *  boolean startsWith(String prefix, int toffset)：測(cè)試此字符串從指定索引開(kāi)始的
 * 子字符串是否以指定前綴開(kāi)始
 *
 *  boolean contains(CharSequence s)：當(dāng)且僅當(dāng)此字符串包含指定的 char 值序列時(shí)，返回 true
 *  int indexOf(String str)：返回指定子字符串在此字符串中第一次出現(xiàn)處的索引
 *  int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出
 * 現(xiàn)處的索引，從指定的索引開(kāi)始
 *  int lastIndexOf(String str)：返回指定子字符串在此字符串中最右邊出現(xiàn)處的索引
 *  int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出現(xiàn)處的索引，從指定的索引開(kāi)始反向搜索
 * 注：indexOf和lastIndexOf方法如果未找到都是返回-1
 *
 *  String replace(char oldChar, char newChar)：返回一個(gè)新的字符串，它是
 * 通過(guò)用 newChar 替換此字符串中出現(xiàn)的所有 oldChar 得到的。
 *  String replace(CharSequence target, CharSequence replacement)：使
 * 用指定的字面值替換序列替換此字符串所有匹配字面值目標(biāo)序列的子字符串。
 *  String replaceAll(String regex, String replacement) ： 使 用 給 定 的
 * replacement 替換此字符串所有匹配給定的正則表達(dá)式的子字符串。
 *  String replaceFirst(String regex, String replacement) ： 使 用 給 定 的
 * replacement 替換此字符串匹配給定的正則表達(dá)式的第一個(gè)子字符串。
 *
 * boolean matches(String regex)：告知此字符串是否匹配給定的正則表達(dá)式
 *
 *  String[] split(String regex)：根據(jù)給定正則表達(dá)式的匹配拆分此字符串。
 *  String[] split(String regex, int limit)：根據(jù)匹配給定的正則表達(dá)式來(lái)拆分此
 * 字符串，最多不超過(guò)limit個(gè)，如果超過(guò)了，剩下的全部都放到最后一個(gè)元素中。
 * @author shc
 * @create 2021-05-20 15:06
 */

String與其他結(jié)構(gòu)的轉(zhuǎn)換
- 與基本數(shù)據(jù)類(lèi)型，包裝類(lèi)之間的轉(zhuǎn)換

/*
    String與基本數(shù)據(jù)類(lèi)型，包裝類(lèi)之間的轉(zhuǎn)換
    String --> 基本數(shù)據(jù)類(lèi)型，包裝類(lèi) :調(diào)用基本數(shù)據(jù)類(lèi)型的 parseXxx（str）;
    基本數(shù)據(jù)類(lèi)型，包裝類(lèi) ---> String :調(diào)用String類(lèi)重載的valueOf（xxx）; 或者直接+""
    */

  @Test
  public void test(){
      String str = "123";
//        int num = (int) str; //必須是子父類(lèi)的關(guān)系才可以強(qiáng)轉(zhuǎn)
      int num = Integer.parseInt(str); //注意str中不能有數(shù)字 否則NumberFormatException
      System.out.println(num);
      String str1 = String.valueOf(num);
      String str2 = num+"";
      System.out.println(str1+" "+str2);
  }

String與字符數(shù)組之間的轉(zhuǎn)換

     /*
  String與char[]之間的轉(zhuǎn)換
  String -->char[] 調(diào)用String的toCharArray()
  char[] -->String 調(diào)用String的構(gòu)造器
   */

      @Test
  public void test2(){
      String str1 = "abc123";
      char[] charArray = str1.toCharArray();
      for(int i=0;i<charArray.length;i++){
          System.out.print(charArray[i]+" ");
      }
      char[] arr = new char[]{'h','e','l','l','o'};
      String str = new String(arr);
      System.out.println(str);
  }

String與字節(jié)數(shù)組之間的轉(zhuǎn)換

  /*
  String與byte[]之間的轉(zhuǎn)換
  編碼：String --> byte[]:調(diào)用String的getBytes()
  解碼：byte[] --> String
  編碼：字符串 --> 字節(jié) （看得懂 --> 看不懂）
  解碼：編碼的逆過(guò)程 字節(jié) --> 字符串 （看不懂的二進(jìn)制 --> 看得懂）
  說(shuō)明：要求編碼時(shí)使用的字符集和解碼時(shí)使用的字符集必須一致
   */

       @Test
  public void test3() throws UnsupportedEncodingException {
      String str1 = "abc123中國(guó)";
      byte[] bytes = str1.getBytes();//使用默認(rèn)的字符集。進(jìn)行轉(zhuǎn)換
      System.out.println(Arrays.toString(bytes));
      byte[] gbks = str1.getBytes("gbk");//使用gbk字符集進(jìn)行編碼
      System.out.println(str1);
      System.out.println(Arrays.toString(gbks));
      System.out.println("****************");
      String str2 = new String(bytes);//使用默認(rèn)字符集進(jìn)行解碼
      System.out.println(str2);
      String gbks1 = new String(gbks);
      System.out.println(gbks1);//亂碼
  }

與StringBuilder,StringBuffer之間的轉(zhuǎn)換

String --> StringBuffer、StringBuilder:調(diào)用StringBuffer、StringBuilder構(gòu)造器
StringBuffer、StringBuilder --> String:
  		①調(diào)用String構(gòu)造器
  		②StringBuffer、StringBuilder的toString()

/*
  String、StringBuilder、StringBuffer三者異同？
  String：不可變的字符序列 ,char型數(shù)組存儲(chǔ)
  StringBuffer：可變的字符序列：線(xiàn)程安全，效率偏低，char型數(shù)組存儲(chǔ)
  StringBuilder：可變的字符序列：jdk5.0新增 線(xiàn)程不安全，效率高，char型數(shù)組存儲(chǔ)
  三者效率：StringBuilder > StringBuffer > String
  源碼分析：
  String str = new String(); //char[] value = new char[0];
  String str1 = new String("abc);//char[] value = new char[]={'a','b','c'};
  StringBuffer sb1 =  new StringBuffer();//char[] value = new char[16];//底層創(chuàng)建了一個(gè)長(zhǎng)度為16的字符串?dāng)?shù)組
  sb1.append('a');//value[0]='a';
  sb1.append('b');//value[1]='b';
  StringBuffer sb2 = new String("abc"); //char[] value = new char["abc".length()+16];
    QUESTION 1：sout(sb2.length()); //"abc".length;
             2：擴(kuò)容問(wèn)題：如果要添加的數(shù)據(jù)底層數(shù)組撐不下了，就要擴(kuò)容底層的數(shù)組
             默認(rèn)情況下，擴(kuò)容為原來(lái)容量的2倍+2，同時(shí)將原有數(shù)組中的元素復(fù)制到新的數(shù)組中。
             指導(dǎo)意義：開(kāi)發(fā)中建議大家使用：StringBuffer（int capacity)或者(StringBuilder(int capacity) 盡量避免擴(kuò)容，影響效率
   */
  @Test
  public void test(){
      StringBuffer str1 = new StringBuffer("abc");
      str1.setCharAt(0,'n');
      System.out.println(str1);
  }

JVM中字符常量池存放位置說(shuō)明：

jdk 1.6(jdk 6.0，java 6.0)：字符串常量池儲(chǔ)存在方法區(qū)（永久區(qū)）
jdk 1.7：字符串常量池存儲(chǔ)在堆空間
jdk 1.8：字符

StringBuilder，StringBuffer

public class StringBuilderBufferTest {
    /*
    String、StringBuilder、StringBuffer三者異同？
    String：不可變的字符序列 ,char型數(shù)組存儲(chǔ)
    StringBuffer：可變的字符序列：線(xiàn)程安全，效率偏低，char型數(shù)組存儲(chǔ)
    StringBuilder：可變的字符序列：jdk5.0新增 線(xiàn)程不安全，效率高，char型數(shù)組存儲(chǔ)
    三者效率：StringBuilder > StringBuffer > String
    源碼分析：
    String str = new String(); //char[] value = new char[0];
    String str1 = new String("abc);//char[] value = new char[]={'a','b','c'};
    StringBuffer sb1 =  new StringBuffer();//char[] value = new char[16];//底層創(chuàng)建了一個(gè)長(zhǎng)度為16的字符串?dāng)?shù)組
    sb1.append('a');//value[0]='a';
    sb1.append('b');//value[1]='b';
    StringBuffer sb2 = new String("abc"); //char[] value = new char["abc".length()+16];
      QUESTION 1：sout(sb2.length()); //"abc".length;
               2：擴(kuò)容問(wèn)題：如果要添加的數(shù)據(jù)底層數(shù)組撐不下了，就要擴(kuò)容底層的數(shù)組
               默認(rèn)情況下，擴(kuò)容為原來(lái)容量的2倍+2，同時(shí)將原有數(shù)組中的元素復(fù)制到新的數(shù)組中。
               指導(dǎo)意義：開(kāi)發(fā)中建議大家使用：StringBuffer（int capacity)或者(StringBuilder(int capacity) 盡量避免擴(kuò)容，影響效率
     */
    @Test
    public void test(){
        StringBuffer str1 = new StringBuffer("abc");
        str1.setCharAt(0,'n');
        System.out.println(str1);
    }
}

/*
* StringBuffer類(lèi)不同于String，其對(duì)象必須使用構(gòu)造器生成。有三個(gè)構(gòu)造器：
    StringBuffer()：初始容量為16的字符串緩沖區(qū)
    StringBuffer(int size)：構(gòu)造指定容量的字符串緩沖區(qū)
    StringBuffer(String str)：將內(nèi)容初始化為指定字符串內(nèi)容
常用方法
    StringBuffer append(xxx)：提供了很多的append()方法，用于進(jìn)行字符串拼接
    StringBuffer delete(int start,int end)：刪除指定位置的內(nèi)容
    StringBuffer replace(int start, int end, String str)：把[start,end)位置替換為str
    StringBuffer insert(int offset, xxx)：在指定位置插入xxx
    StringBuffer reverse() ：把當(dāng)前字符序列逆轉(zhuǎn)
*   public int indexOf(String str)
    public String substring(int start,int end)
    public int length()
    public char charAt(int n )
    public void setCharAt(int n ,char ch)
*
* 總結(jié)
    * 增 append(x)
    * 刪 delete(int start,int end)
    * 改 setCharAt(int n,char ch) / repalce(int start,int end,String str)
    * 查 charAt(int n)
    * 插 insert(int offset,xxx)
    * 長(zhǎng)度 length()
    * 遍歷 for()+charAt() / toString()
*
 */

面試題

JDK8之前的時(shí)間API

獲取當(dāng)前系統(tǒng)時(shí)間java.lang.System類(lèi)中的currentTimeMillis()

long time = System.currentTimeMillis();
//返回時(shí)間為當(dāng)前時(shí)間與1970年1月1日00:00之間以ms為單位的時(shí)間差，稱(chēng)為時(shí)間戳
System.out.println(time);
//1621602510493

java.util.Date與java.sql.Date

java.sql.Date extends java.util.Date

       /*
    2. java.util.Date類(lèi)
    ① 兩個(gè)構(gòu)造器的使用
        >構(gòu)造器一：Date（）創(chuàng)建一個(gè)對(duì)應(yīng)當(dāng)前時(shí)間的Date對(duì)象
        >構(gòu)造器二：創(chuàng)建指定毫秒數(shù)(指定時(shí)間戳)的Date對(duì)象
    ② 兩個(gè)方法的使用
        >toString():顯示當(dāng)前的年、月、日、時(shí)、分、秒
        >getTime();獲取當(dāng)前Date對(duì)象的時(shí)間戳
    ③  java.sql.Date類(lèi) extends java.util.Date
        >如何實(shí)例化
        >如何將java.util.Date對(duì)象轉(zhuǎn)化為java.sql.Date對(duì)象
     */
    @Test
    public void test2(){
        //構(gòu)造器一：Date（）創(chuàng)建一個(gè)對(duì)應(yīng)當(dāng)前時(shí)間的Date對(duì)象
        Date date1 = new Date();
        System.out.println(date1.toString());//Fri May 21 21:07:33 CST 2021
        System.out.println(date1.getTime());//1621602495849
        //構(gòu)造器二：創(chuàng)建指定毫秒數(shù)的Date對(duì)象
        Date date2 = new Date(1621602495849L);
        System.out.println(date2.toString());//FriMay 21 21:08:15 CST 2021
        //或者直接date2也一樣，因?yàn)閟out就是會(huì)調(diào)用toString啊。
        //這可不是把Date類(lèi)對(duì)象轉(zhuǎn)化成String類(lèi)對(duì)象了?。。。。。?！
        System.out.println("*****************");
        //創(chuàng)建java.sql.Date對(duì)象
        java.sql.Date date3 = new java.sql.Date(323156136L);
        System.out.println(date3);//1970-01-05
        //如何將java.util.Date對(duì)象轉(zhuǎn)化為java.sql.Date對(duì)象
        //情況1：(Java多態(tài)）
        Date date4 = new java.sql.Date(1235346456L);
        java.sql.Date date5 = (java.sql.Date)date4;
        //情況2：
        Date date6 = new Date();
        java.sql.Date date7 = new java.sql.Date(date6.getTime());
        //而不能是java.sql.Date date7 = (java.sql.Date)date6;
    }

java.text.SimpleDateFormat類(lèi)

用處：SimpleDateFormat對(duì)日期Date類(lèi)的格式化和解析（Date里還有很多方法被@Deprecated了）（JDK8建議用Calendar）

（1）兩個(gè)操作
- 1.1： 格式化：日期（Date） --> 字符串（String）
- 1.2：解析：格式化的逆過(guò)程：字符串（String） --> 日期（Date）
（2）SimpleDateFormat的實(shí)例化：new+構(gòu)造器.
- 基本操作

 	//1. 實(shí)例化SimpleDateFormat
    SimpleDateFormat sdf = new SimpleDateFormat();
    //2. 格式化：日期 (Date)--> 字符串(String)
    Date date = new Date(); //Date（）創(chuàng)建一個(gè)對(duì)應(yīng)當(dāng)前時(shí)間的Date對(duì)象
    System.out.println(date);// Sat May 22 19:50:32 CST 2021
    String format = sdf.format(date); // SimpleDateFormat對(duì)Date進(jìn)行解析，獲得字符串：21-5-22 下午7:50
    System.out.println(format); // 輸出解析后得到的字符串 21-5-22 下午7:50
    //解析：格式化的逆過(guò)程。字符串(String) ---> 日期(Date)
    String str = "21-5-22 下午7:49";
    Date date1 = sdf.parse(str);//可能導(dǎo)致編譯異常原因：字符串格式不對(duì)
    System.out.println(date1);//Sat May 22 19:49:00 CST 2021

（3）以下為開(kāi)發(fā)中主要方式 --> 按照指定方式格式化和解析：調(diào)用帶參構(gòu)造器

          //開(kāi)發(fā)中通常不用默認(rèn)構(gòu)造器，而是用指定的構(gòu)造器來(lái)確定格式化方式
        //SimpleDateFormat sdf2 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
        //年 yyyy -- 月 MM (大寫(xiě)是為了和分鐘mm區(qū)分開(kāi)) -- 天 dd -- 時(shí) hh -- 分鐘 mm -- 秒 ss
        //1. 實(shí)例化    
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd ---- hh:mm:ss");
		//2. 格式化
        String format2 = sdf2.format(date);//以我們制定的yyyy-MM-dd ---- hh:mm:ss格式來(lái)進(jìn)行轉(zhuǎn)化
        System.out.println(format2);//2021-05-23 ---- 01:22:21
		//3. 解析:
		//要求字符串必須是符合SimpleDateFormat識(shí)別的格式（通過(guò)構(gòu)造器參數(shù)體現(xiàn)），否則就會(huì)拋出異常
        Date date2 = sdf2.parse("2021-05-23 ---- 01:22:21");
        System.out.println(date2);//Sun May 23 01:22:21 CST 2021

Calendar類(lèi)：日歷類(lèi)，抽象類(lèi)

  /*
    Calendar日歷類(lèi)（抽象類(lèi)）的使用
     */
    @Test
    public void testCalendar(){
        //1.實(shí)例化
        //方式一：創(chuàng)建其子類(lèi)(GregorianCalendar)的對(duì)象
        //方式二：調(diào)用其靜態(tài)方法getInstance();
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getClass());//class java.util.GregorianCalendar
        //2.常用方法
        //get()
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//23
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//143
        //set()
        //Calendar劣勢(shì)：可變性
        calendar.set(Calendar.DAY_OF_MONTH,7);//void set() 把Calendar本身給改了
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//7
        //add()
        calendar.add(Calendar.DAY_OF_MONTH,-3);//4
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
        //getTime():日歷類(lèi) ---> Date
        Date date = calendar.getTime();
        System.out.println(date);//Tue May 04 13:45:07 CST 2021
        System.out.println("****************");
        //setTime():Date --> 日歷類(lèi)
        Date date1 = new Date();
        calendar.setTime(date1);
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//23

JDK8中新的API
- 日期時(shí)間API的迭代
- 第一代：jdk 1.0 Date類(lèi)
- 第二代：jdk 1.1 Calendar類(lèi)，一定程度上替換Date類(lèi)
- 第三代：jdk1.8提出了新的一套API（最終版）
前兩代存在的問(wèn)題
- 可變性：像日期和時(shí)間這樣的類(lèi)應(yīng)該是不可變的。
- 偏移性：Date中的年份是從1900開(kāi)始的，而月份都從0開(kāi)始。
- 格式化：格式化只對(duì)Date有用，Calendar則不行。
- 此外，它們也不是線(xiàn)程安全的；不能處理閏秒等。

本地日期、本地時(shí)間、本地日期時(shí)間的使用：LocalDate、LocalTime、LocalDateTime

說(shuō)明：
- LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存儲(chǔ) 生日、紀(jì)念日等日期。
- LocalTime表示一個(gè)時(shí)間，而不是日期。
- LocalDateTime是用來(lái)表示日期和時(shí)間的，這是一個(gè)最常用的類(lèi)之一。
常用方法：

時(shí)間點(diǎn)：Instant

說(shuō)明：
- Instant表示時(shí)間線(xiàn)上的一點(diǎn)，而不需要任何上下文信息，例如，時(shí)區(qū)。概念上講，它只是簡(jiǎn)單的表示自1970年1月1日0時(shí)0分0秒（UTC）開(kāi)始的秒數(shù)。
- 類(lèi)似于java.util.Date類(lèi)
常用方法

日期時(shí)間格式化類(lèi)：DateTimeFormatter

說(shuō)明

格式化、解析日期，時(shí)間
類(lèi)似于SimpleDateFormat

常用方法

實(shí)例化方法
- 預(yù)定義的標(biāo)準(zhǔn)格式。如： ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
- 本地化相關(guān)的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
- 自定義的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
常用方法：

特別的，自定義格式，如:如：ofPattern(“yyyy-MM-dd hh:mm:ss”)*

     //方式三：自定義的格式。如：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-05-22 11:07:16
        //解析：
        TemporalAccessor accessor = formatter3.parse("2021-05-22 03:06:09");
        System.out.println(accessor);
        //{NanoOfSecond=0, MilliOfSecond=0, MinuteOfHour=6, SecondOfMinute=9, MicroOfSecond=0, HourOfAmPm=3},ISO resolved to 2021-05-22
    }

其他常用類(lèi)

package com.shc.java1;
import org.junit.Test;
import java.math.BigDecimal;
import java.math.BigInteger;
/**
 * 1. System
 * 2. Math
 * 3. BigInteger BigDecimal
 * @author shc
 * @create 2021-05-23 12:29
 */
public class OtherTest {
    @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);
    }
    @Test
    public void test2(){
        BigInteger bi = new BigInteger("12433241123");
        BigDecimal bd = new BigDecimal("12435.351");
        BigDecimal bd2 = new BigDecimal("10");
        System.out.println(bi);
//         System.out.println(bd.divide(bd2)); 魏沒(méi)有指明精度 如果除不盡的話(huà)會(huì)異常
        System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));//四舍五入
        System.out.println(bd.divide(bd2, 20, BigDecimal.ROUND_HALF_UP)); //scale：小數(shù)位位數(shù) 支持任意精度的小數(shù)位
    }
}

Java比較器·

引入

 * 說(shuō)明：Java中的對(duì)象中，正常情況下，只能進(jìn)行比較：== 或者 != 不能使用>或者<的
 *      但是在開(kāi)發(fā)場(chǎng)景中，我們需要對(duì)多個(gè)對(duì)象進(jìn)行排序，言外之意，就是要比較對(duì)象的大小
 *      如何實(shí)現(xiàn)? 使用兩個(gè)接口中的任何一個(gè)：Comparable 或 Compare任意一個(gè)

自然排序Comparable

說(shuō)明

     /*
    Comparable接口使用舉例：自然排序
    1. 像String、包裝類(lèi)等實(shí)現(xiàn)了Comparable接口，重寫(xiě)compareTo()方法，給出比較兩個(gè)對(duì)象大小的方式
    2. 像String、包裝類(lèi)重寫(xiě)了compareTo方法以后，進(jìn)行了從小到大的排列
    3. 重寫(xiě)compareTo()的規(guī)則
    如果當(dāng)前對(duì)象this大于形參對(duì)象obj，則返回正整數(shù)，
    如果當(dāng)前對(duì)象this小于形參對(duì)象obj，則返回負(fù)整數(shù)，
    如果當(dāng)前對(duì)象this等于形參對(duì)象obj，則返回零。
    4. 對(duì)于自定義類(lèi)來(lái)說(shuō)，如果需要排序，我們可以自定義類(lèi)實(shí)現(xiàn)Comparable接口，重寫(xiě)compareTo方法，
        在compareTo(obj)指明如何排序。
     */

代碼舉例

/**
 * 商品類(lèi)
 * @author shc
 * @create 2021-05-23 10:57
 */
public class Goods implements Comparable{
    private String name;
    private double price;
    //指明商品比較方式，先按照價(jià)格遞增，再按照名字遞增
    @Override
    public int compareTo(Object o){
        System.out.println("==================");
        if(o instanceof Goods){
            Goods good = (Goods) o;
            if(good.price<this.price){
                return 1;
            }else if(good.price>this.price){
                return -1;
            }else{
                return this.name.compareTo(good.name); //再按照名字排序
//                return 0;
            }
            //方式二
//            return Double.compare(this.price,((Goods)o).price);
        }
         throw new RuntimeException("傳入數(shù)據(jù)類(lèi)型不一致錯(cuò)誤");
    }
}
    @Test
    public void test2(){
        Goods[] goods = new Goods[5];
        int x = goods.length;
        System.out.println(goods.length);//5 是數(shù)組本身的長(zhǎng)度
        goods[0] = new Goods("shubiao",12);
        goods[1] = new Goods("diannao",78);
        goods[2] = new Goods("erji",10);
        goods[3] = new Goods("xianshiqi",1);
        goods[4] = new Goods("xian",1);
        Arrays.sort(goods,0,goods.length);
        for(int i=0;i<goods.length;i++){
            System.out.println(goods[i]);
        }
    }

    /*sort方法時(shí)回調(diào)用compareTo*/
==================
==================
==================
==================
==================
==================
==================
==================
==================
Goods{name='xian', price=1.0}
Goods{name='xianshiqi', price=1.0}
Goods{name='erji', price=10.0}
Goods{name='shubiao', price=12.0}
Goods{name='diannao', price=78.0}

定制排序 Comparator

引入

當(dāng)元素的類(lèi)型沒(méi)有實(shí)現(xiàn)java.lang.Comparable接口而又不方便修改代碼，或者實(shí)現(xiàn)了java.lang.Comparable接口的排序規(guī)則不適合當(dāng)前的操作，那么可以考慮使用 Comparator 的對(duì)象來(lái)排序，強(qiáng)行對(duì)多個(gè)對(duì)象進(jìn)行整體排序的比較。
- 重寫(xiě)compare(Object o1,Object o2)方法，比較o1和o2的大小：如果方法返回正整數(shù)，則表示o1大于o2；如果返回0，表示相等；返回負(fù)整數(shù)，表示 o1小于o2。 l 可以將 Comparator 傳遞給 sort 方法（如 Collections.sort 或 Arrays.sort），從而允許在排序順序上實(shí)現(xiàn)精確控制。
- 還可以使用 Comparator 來(lái)控制某些數(shù)據(jù)結(jié)構(gòu)（如有序 set或有序映射）的順序，或者為那些沒(méi)有自然順序的對(duì)象 collection 提供排序。
代碼

        Arrays.sort(goods,new Comparator(){//接口可以new嗎？
            @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())){//名字相同時(shí) 按照價(jià)格遞減
                        return -Double.compare(g1.getPrice(),g2.getPrice());
                    }else{
                        return g1.getName().compareTo(g2.getName());
                    }
                }
                throw new RuntimeException(o1+"輸入數(shù)據(jù)類(lèi)型錯(cuò)誤");
                //如果有一個(gè)數(shù)組元素為空的話(huà)也會(huì)走到這里 因?yàn)閚ull instanceof Goods 為false 不會(huì)進(jìn)入if
                //如果用的是o1.toString()的話(huà)則會(huì)是NullPointerException 因?yàn)樵趖hrowRuntimeException的時(shí)候會(huì)走到toString()這一步 而null調(diào)用toString()則是空指針異常
            }
        });

兩種排序方式對(duì)比

/* 二、Comparable接口與Comparator的使用的對(duì)比
 *  Comparable接口的方式一旦設(shè)定，保證了Comparable接口實(shí)現(xiàn)類(lèi)的對(duì)象在任意位置都可以比較大小
 *  Comparator接口屬于臨時(shí)性的比較
 */

每日一考

畫(huà)出如下幾行代碼的內(nèi)容結(jié)構(gòu)

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
s1+="world";   <--->    s1 = s1+"hello"; 右則有變量s1參與，所以拼接結(jié)果在堆中

如何理解String類(lèi)的不可變性
String類(lèi)是否可以被繼承？為什么？
String、StringBuffer、StringBuilder三者對(duì)比
String的常用方法有哪些？（至少7個(gè)）

length()/charAt()/equals()/compareTo()...

每日一考將字符串“2017-08-16”轉(zhuǎn)化為對(duì)應(yīng)的java.sql.Date類(lèi)的對(duì)象(把頁(yè)面?zhèn)魅氲淖址嫒霐?shù)據(jù)庫(kù)中)（是一個(gè)解析過(guò)程） //其實(shí)也可以直接塞進(jìn)去（但我們一定要會(huì)手動(dòng)轉(zhuǎn)化）
字符串-->java.util.Date date --> longms時(shí)間戳- -->java.sql.Date

SimpleDateFormat    
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy--MM--dd");
//	解析（字符串String-->日期Date）：
    java.util.Date utilDate = sdf.parse("2021-02-23");
//	再用date來(lái)getTime（）（返回的是longms），再放入構(gòu)造器中
	java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
DateTimeFormatter   
    DateTimeFormatterdtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
	..............
實(shí)例化方式：
    new +構(gòu)造器
    單例模式（private構(gòu)造器）
    Calendar.getInstance()//Calendar是一個(gè)抽象類(lèi)，獲取的是他的子類(lèi)（private構(gòu)造器）

解釋何為編碼？解碼？何為日期時(shí)間的格式化，解析？

編碼：字符串 -> 字節(jié)

解碼：字節(jié) -> 字符串

格式化（format）：日期 ->字符串

解析（parse）：字符串 -> 日期

自定義Person類(lèi)如下，如何實(shí)現(xiàn)自然排序？（按照名字從小到大）

class Person implements Comparable{
    private String name;
    @Override
    public int compareTo(Object o){
        if(o instanceof Person){
            Person p = (Person) o;
            return this.name.compareTo(p.name);
        }
        throw new Exception("");
    }
}

提供定制排序涉及到的接口的實(shí)現(xiàn)類(lèi)對(duì)象，并按Person類(lèi)的年齡從大到小排序

Comparator cp = new Comparator(){
    @Override
    public int compare(Object obj1,Object obj2){
        if(..)
    }
}

JDK8 之前和 JDK8 中與日期、時(shí)間相關(guān)的類(lèi)分別有哪些？

JDK8之前								JDK8
java.util.Date 和 java.sql.Date ---> instant			 (本初子午線(xiàn)的時(shí)間)
SimpleDateFormat				--->DateTimeFormatter
Calendar						--->LocalDate,LocalTime,LocalDateTime