文章目錄

一、前言
二、String類
- 1.理解String的不可變性
- 2.String不同實體化方式對比
- 3.String不同拼接操作的對比
- 4.String常用方法
- 5.String類與其他結構之間的轉換
三、StringBuffer類和StringBuilder類
- 1.StringBuffer分析（StringBuilder同理）
- 2.StringBuffer常用方法（StringBuilder同理）
- 3.效率對比
四、JDK8之前日期和時間API
- 1.System.currentTimeMillis()
- 2.Date類
- 3.SimpleDateFormat類
- 4.Calendar類
五、JDK8中新日期和時間API
- 1. LocalDate、LocalTime、LocalDateTime
- 2.Instant類
- 3.DateTimeFormatter類
六、Java比較器
- 1.自然排序：Comparable介面
- 2.定制排序：Comparator介面
七、System類
八、Math類
九、BigInteger類
十、BigDecimal類

一、前言

這篇技術博客是我復習尚硅谷JavaSE教程做的筆記總結，方便大家的學習同時也方便自己，博客內容非復制粘貼，純手寫，如果對你有幫助，歡迎點贊評論收藏！

二、String類

1.理解String的不可變性

String：字串，使用""引起來表示

String宣告為final的，不能被繼承
String實作了Serializable介面：表示字串是支持序列化的
實作了Comparable介面：表示String可以比較大小
String在內部定義了final char[] value用于存盤字串資料
String：代表不可變的字符序列，簡稱：不可變性，(只要對字串內容進行任何修改，都必須重新造！)

  體現：
     1.當對字串重新賦值時，需要重寫指定記憶體區域賦值，不能使用原有的value進行賦值
     2.當對現有的字串進行連接操作時，也需要重新指定記憶體區域賦值，不能在原有的value上進行賦值
     3.當呼叫String的replace()修改指定字符或字串時，也需要重新指定記憶體區域賦值

通過字面量的方式（區別于new）給一個字串賦值，此時的字串值宣告在字串常量池中
字串常量池中是不會存盤相同內容的字串的，

圖解如下：
在這里插入圖片描述

附加：JVM中字符串常量池存放位置說明

JDK1.6：字串常量池存盤在方法區（永久區）
JDK1.7：字串常量池存盤在堆空間
JDK1.8：字串常量池存盤在方法區（元空間）

2.String不同實體化方式對比

String共有兩種實體化的方式：

通過字面量定義的方式
通過new + 構造器方式

/**
 * 面試題：String s = new String("abc");方式創建物件，在記憶體中創建了幾個物件？
 *       兩個：一個是堆空間中new結構，另一個是char[]對應的常量池中的資料："abc"
 */
public class StringTest {
    @Test
    public void test1(){
        //此時的s1和s2資料宣告在方法區中的字串常量池中
        String s1 = "abc";
        String s2 = "abc";

        //new + 構造器方式：此時的s3和s4保存的地址值，是資料在堆空間中開辟空間后對應的地址值
        String s3 = new String("abc");
        String s4 = new String("abc");

        System.out.println(s1 == s2); //true 因為字串常量存盤在方法區的常量池中，是唯一的（共享）
        System.out.println(s1 == s3); //false s1指向常量池中的地址，s3指向堆空間地址
        System.out.println(s1 == s4); //false s1指向常量池中的地址，s4指向對空間地址
        System.out.println(s3 == s4); //false s3和s4都指向堆空間地址，但是地址值不同
    }
}

總結：字串分兩種實體化方式，通過字面量實體化就存盤在方法區的常量池中，通過new方式就存盤在堆空間中，常量池中的常量是唯一且不可修改的，如果想使用新的常量，只能在池中創建新的！
在這里插入圖片描述

3.String不同拼接操作的對比

結論：

1.常量與常量的拼接結果在常量池，且常量池中不會存在相同內容的常量，
2.只要其中有一個是變數，結果就在堆中
3.如果拼接的結果呼叫intern()方法，回傳值就在常量池中

public class StringTest {
    @Test
    public void test1(){
        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 常量和變數拼接，地址就在堆空間中，所以沒指向同一個地址
        System.out.println(s3 == s6); //false 同理
        System.out.println(s5 == s6); //false 同理
        System.out.println(s3 == s7); //false 同理
        System.out.println(s5 == s7); //false 同理
        System.out.println(s6 == s7); //false 同理

        String s8 = s5.intern(); //回傳值得到的s8使用的常量池中已經存在的"JavaEEhadoop"
        System.out.println(s3 == s8); //true
    }

	@Test
    public void test1(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3); //false

        final String s4 = "javaEE"; //s4是常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5); //true 原因：看結論1
    }
}

4.String常用方法

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 equalsIgnoreCase(String anotherString)：與equals方法類似，忽略大小寫
String concat(String str)：將指定字串連接到此字串的結尾，等價于用“+”
int compareTo(String anotherString)：比較兩個字串的大小
String substring(int beginIndex)：回傳一個新的字串，它是此字串的從beginIndex開始截取到最后的一個子字串，
String substring(int beginIndex, int endIndex) ：回傳一個新字串，它是此字串從beginIndex開始截取到endIndex(不包含)的一個子字串，
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)：回傳指定子字串在此字串中最后一次出現處的索引，從指定的索引開始反向搜索
注：indexOf和lastIndexOf方法如果未找到都是回傳-1
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 StringTest {
    @Test
    public void test1(){
        //length()
        String s1 = "HelloWorld";
        System.out.println(s1.length()); //10

        //charAt()
        System.out.println(s1.charAt(0)); //H
        System.out.println(s1.charAt(9)); //d

        //isEmpty()
        System.out.println(s1.isEmpty()); //false

        //toLowerCase()
        String s2 = s1.toLowerCase();
        System.out.println(s2); //helloworld

        //toUpperCase()
        String s3 = s1.toUpperCase();
        System.out.println(s3); //HELLOWORLD

        //trim()
        String s4 = "     hello world     ";
        String s5 = s4.trim();
        System.out.println("---" + s4 + "---"); //---     hello world     ---
        System.out.println("---" + s5 + "---"); //---hello world---
    }

    @Test
    public void test2(){
        //equalsIgnoreCase()
        String s1 = "HelloWorld";
        String s2 = "helloworld";
        System.out.println(s1.equals(s2)); //false
        System.out.println(s1.equalsIgnoreCase(s2)); //true

        //concat()
        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4); //abcdef

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

        //substring()
        String s7 = "北京天安門廣場";
        System.out.println(s7.substring(2)); //天安門廣場

        //endIndex()
        System.out.println(s7.substring(2, 5)); //天安門
    }

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

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

        //contains()
        String str2 = "wo";
        System.out.println(str1.contains(str2)); //true

        //indexOf()
        System.out.println(str1.indexOf("lo")); //3
        System.out.println(str1.indexOf("lol")); //-1
        System.out.println(str1.indexOf("lo",5)); //-1

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

        //什么情況下，indexOf(str)和lastIndexOf(str)回傳值相同？
        //1.存在唯一的的一個str     2.不存在str
    }

    @Test
    public void test4(){
        //replace()
        String str1 = "北京尚硅谷教育北京";
        String str2 = str1.replace('北', '東');
        String str3 = str1.replace("北京", "上海");
        System.out.println(str1); //北京尚硅谷教育北京
        System.out.println(str2); //東京尚硅谷教育東京
        System.out.println(str3); //上海尚硅谷教育上海
    }
}

5.String類與其他結構之間的轉換

/**
 * 涉及到String類與其他結構之間的轉換
 */
public class StringTest {
    @Test
    public void test1(){
        //String--->基本資料型別、包裝類
        String str1 = "123";
        int num = Integer.parseInt(str1); //123

        //基本資料型別、包裝類--->String
        String str2 = String.valueOf(num); //"123"
        String str3 = num + "";
    }

    @Test
    public void test2(){
        /*
        String與char[]之間的轉換
         */


        //String--->char[]:呼叫String的toCharArray()
        String str1 = "abc123";
        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }

        //char[]--->String:呼叫String的構造器
        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2); //hello
    }

    @Test
    public void test3() throws UnsupportedEncodingException {
        /*
        String與byte[]之間轉換

        編碼：字串--->位元組（看得懂--->看不懂）
        解碼：編碼的逆程序，位元組--->字串（看不懂的二進制資料--->看得懂）
        
        說明：解碼時，要求解碼使用的字符集必須與編碼時使用的字符集一致，否則會出現亂碼
         */

        //編碼：String--->byte[]:呼叫
        String str1 = "abc123中國";
        byte[] bytes = str1.getBytes(); //使用默認的字符集(utf-8)進行編碼
        //[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk"); //使用gbk字符集進行編碼
        //[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]
        System.out.println(Arrays.toString(gbks));


        //解碼：byte[]--->String:呼叫String構造器
        String str2 = new String(bytes); //使用默認的字符集，進行解碼
        System.out.println(str2); //abc123中國

        String str3 = new String(gbks);
        System.out.println(str3); //出現亂碼，原因：編碼集和解碼集不一致！

        String str4 = new String(gbks, "gbk");
        System.out.println(str4); //沒有出現亂碼，原因：編碼集和解碼集一致！
    }
}

三、StringBuffer類和StringBuilder類

1.StringBuffer分析（StringBuilder同理）

StringBuffer類不同于String，其物件必須使用構造器生成，

StringBuffer()：初始容量為16的字串緩沖區
StringBuffer(int size)：構造指定容量的字串緩沖區
StringBuffer(String capacity)：將內容初始化為指定字串內容

String、StringBuffer、StringBuilder三者異同？
    String:不可變的字符序列；底層結構使用char[]存盤
    StringBuffer:可變的字符序列，執行緒安全的，效率低；底層結構使用char[]存盤
    StringBuilder:可變的字符序列，jdk5.0新增，執行緒不安全的，效率高；底層結構使用char[]存盤
    
	
	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]; 底層創建了一個長度是16的陣列
    sb1.append('a'); //value[0] = 'a';
    sb1.append('b'); //value[1] = 'b';

    StringBuffer sb2 = new StringBuffer("abc"); //char[] value = new char["abc".length() + 16];

    問題1：System.out.println(sb2.length()); //3
    問題2：擴容問題：如果要添加的資料底層陣列盛不下了，那就需要擴容底層陣列
          默認情況下，擴容為原來容量的2倍 + 2，同時將原有陣列中的元素復制到新的陣列中

    指導意義：在開發中，建議大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

注意：String、StringBuffer、StringBuilder三者之間如何轉換？

String-->StringBuffer、StringBuilder:
			1.呼叫StringBuffer、StringBuilder構造器
StringBuffer、StringBuilder-->String:
			1.呼叫String構造器
			2.StringBuffer、StringBuilder的toString()

理解：關于StringBuffer和StringBuilder這兩個類，它們之間除了類名不同，唯一的區別就是：是否同步（synchronized）

2.StringBuffer常用方法（StringBuilder同理）

String類中定了許多方法，StringBuffer中也有，但是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索引結束的左閉右開區間的子字串1
public int length()
public char charAt(int n)
public void setCharAt(int n ,char ch)

代碼展示：

public class StringTest {

    @Test
    public void test2(){
        //append()
        StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append('1');
        System.out.println(s1); //abc11

        //delete()
        //s1.delete(2,4); //ab1

        //replace()
        //s1.replace(2,4,"hello"); //abhello1

        //insert()
        //s1.insert(2,false); //abfalsec11

        //reverse()
        //s1.reverse(); //11cba

        //sustring()
        //String s2 = s1.substring(1, 3); //bc
    }
}

總結：

增：append(xxx)
刪：delete(int start,int end)
改：setCharAt(int n ,char ch)
查：charAt(int n)
插：insert(int offset, xxx)
長度：length()
遍歷：for() + charAt(int n)  /  toString()

3.效率對比

接下來我們探討一下：String、StringBuffer、StringBuilder三者之間的效率對比

代碼展示：

public class StringTest {
    @Test
    public void test2(){
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");

        //開始對比
        //StringBuffer時間
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的執行時間：" + (endTime - startTime));

        //StringBuilder測驗時間
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的執行時間：" + (endTime - startTime));

        //String測驗時間
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的執行時間：" + (endTime - startTime));
    }
}

運行結果如下：
在這里插入圖片描述

總結：
效率由高到低排名為：StringBuilder > StringBuffer > String

四、JDK8之前日期和時間API

1.System.currentTimeMillis()

代碼展示：

public class StringTest {

    //1.System類中的currentTimeMillis()
    @Test
    public void test1() {
        //回傳當前時間與1970年1月1日0時0分0秒之間以毫秒為單位的時間差，
        //稱為：時間戳
        long time = System.currentTimeMillis();
        System.out.println(time);
    }

2.Date類

    /*
    java.util.Date類
            |---java.sql.Date類

    1.兩個構造器的使用
        >構造器一：Date()：創建一個對應當前時間Date物件
        >構造器二：創建指定毫秒數的Date物件
    2.兩個方法的使用
        >toString():顯示當前的年、月、日、時、分、秒
        >getTime():獲取當前Date物件對應的毫秒數，（時間戳）

    3.java.sql.Date對應著資料庫中的日期型別的變數
        >如何實體化
        >如何將java.util.Date轉換為java.sql.Date物件
     */

    @Test
    public void test2(){
        //構造器一：Date()：創建一個對應當前時間Date物件
        Date date1 = new Date();
        System.out.println(date1); //Tue Feb 09 14:10:37 CST 2021
        System.out.println(date1.getTime()); //1612851112558

        //構造器二：創建指定毫秒數的Date物件
        Date date2 = new Date(1612851112558L);
        System.out.println(date2);

        //創建java.sql.Date物件
        java.sql.Date date3 = new java.sql.Date(321312213L);
        System.out.println(date3.toString()); //1970-01-05

        //如何將java.util.Date轉換為java.sql.Date物件
        //情況一：
        Date date4 = new java.sql.Date(123231312313L);
        java.sql.Date date5 = (java.sql.Date) date4;
        //情況二：
        Date date6 = new Date();
        java.sql.Date date7 = new java.sql.Date(date6.getTime());
    }
}

3.SimpleDateFormat類

Date類的API不易于國際化，大部分被廢棄了，java.text.SimpleDateFormat類是一個不與語言環境有關的方式來格式化和決議日期的具體類，

格式化：
1. SimpleDateFormat() ：默認的模式和語言環境創建物件
2. public SimpleDateFormat(String pattern)：該構造器可以用引數pattern指定的格式創建一個物件
3. public String format(Date date)：方法格式化時間物件date

決議：
1. public Date parse(String source)：從給定字串的開始決議文本，以生成一個日期，

代碼展示：

/**
 * JDK 8之前的日期時間的API測驗
 * 1.System類中currentTimeMillis();
 * 2.java.util.Date和子類java.sql.Date
 * 3.SimpleDateFormat
 * 4.Calendar
 */
public class DateTimeTest {
    /*
    SimpleDateFormat的使用：對日期Date類的格式化和決議

    1.兩個操作：
        1.格式化：日期物件--->字串
        2.決議：格式化逆程序，字串--->日期物件

    2.SimpleDateFormat的實體化

     */

    @Test
    public void testSimpleDateFormat() throws ParseException {
        //實體化SimpleDateFormat:使用默認構造器
        SimpleDateFormat sdf = new SimpleDateFormat();

        //格式化:日期--->字串
        Date date = new Date();
        String format = sdf.format(date);
        System.out.println(format);

        //決議：字串--->日期
        String str = "21-07-07 上午12:00";
        Date date1 = sdf.parse(str);
        System.out.println(date1);


        //按照指定的方式格式化和決議：呼叫帶參的構造器（我們主要使用這種方式！）
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        //格式化
        String format1 = sdf1.format(date);
        System.out.println(format1); //2021-02-10 01:54:58
        //決議:要求字串必須符合SimpleDateFormat識別的格式（通過構造器引數體現）
        //否則，拋例外
        Date date2 = sdf1.parse("2021-02-10 01:54:58");
        System.out.println(date2); //Wed Feb 10 01:54:58 CST 2021
    }
}

4.Calendar類

Calendar是一個抽象基類，主用用于完成日期欄位之間相互操作的功能，

獲取Calendar實體的方法：
1. 使用Calendar.getInstance()方法
2. 呼叫它的子類GregorianCalendar的構造器，

代碼展示：

/**
 * JDK 8之前的日期時間的API測驗
 * 1.System類中currentTimeMillis();
 * 2.java.util.Date和子類java.sql.Date
 * 3.SimpleDateFormat
 * 4.Calendar
 */
public class DateTimeTest {
    /*
     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);
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));

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

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

        //getTime():日歷類--->Date
        Date date = calendar.getTime();
        System.out.println(date);

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

注意：

獲取月份時：一月是0，二月是1，以此類推，12月是11
獲取星期時：周日是1，周二是2 ，，，，，周六是7

五、JDK8中新日期和時間API

為何引進新的API？
JDK 1.0中包含了一個java.util.Date類，但是它的大多數方法已經在JDK 1.1引入Calendar類之后被棄用了，而Calendar并不比Date好多少，它們有許多缺點：

可變性：像日期和時間這樣的類應該是不可變的，
偏移性：Date中的年份是從1900開始的，而月份都從0開始，
格式化：格式化只對Date有用，Calendar則不行，
此外，它們也不是執行緒安全的；不能處理閏秒等，

總結：對日期和時間的操作一直是Java程式員最痛苦的地方之一，

正因如此，我們才需要引進新的API，Java 8中引入的java.time API 已經糾正了過去的缺陷，將來很長一段時間內它都會為我們服務，

1. LocalDate、LocalTime、LocalDateTime

LocalDate、LocalTime、LocalDateTime 類是其中較重要的幾個類，它們的實體是不可變的物件，分別表示使用 ISO-8601日歷系統的日期、時間、日期和時間，它們提供了簡單的本地日期或時間，并不包含當前的時間資訊，不包含與時區相關的資訊，

LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存盤生日、紀念日等日期，
LocalTime表示一個時間，而不是日期，
LocalDateTime是用來表示日期和時間的，這是一個最常用的類之一，

代碼展示：

public class DateTimeTest {
    /*
     LocalDate、LocalTime、LocalDateTime的使用
     說明：
        1.LocalDateTime相較于LocalDate、LocalTime，使用頻率更高
        2.類似于Calendar類
     */

    @Test
    public void test1(){
        //now():獲取當前的日期、時間、日期 + 時間
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println(localDate);
        System.out.println(localTime);
        System.out.println(localDateTime);

        //of():設定指定的年、月、日、時、分、秒，沒有偏移量
        LocalDateTime localDateTime1 = localDateTime.of(2020, 10, 6, 13, 23, 43);
        System.out.println(localDateTime1); //2020-10-06T13:23:43

        //getXxx()：獲取相關的屬性
        System.out.println(localDateTime.getDayOfMonth());
        System.out.println(localDateTime.getDayOfWeek());
        System.out.println(localDateTime.getMonth());
        System.out.println(localDateTime.getMonthValue());
        System.out.println(localDateTime.getMinute());

        //體現不可變性
        //withXxx():設定相關的屬性
        LocalDate localDate1 = localDate.withDayOfMonth(22);
        System.out.println(localDate);
        System.out.println(localDate1);

        LocalDateTime localDateTime2 = localDateTime.withHour(4);
        System.out.println(localDateTime);
        System.out.println(localDateTime2);


        //不可變性
        LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
        System.out.println(localDateTime);
        System.out.println(localDateTime3);

        LocalDateTime localDateTime4 = localDateTime.minusDays(6);
        System.out.println(localDateTime);
        System.out.println(localDateTime4);
    }
}

2.Instant類

Instant：時間線上的一個瞬時點，這可能被用來記錄應用程式中的事件時間戳，

代碼展示：

public class DateTimeTest {
    /*
    Instant的使用
    類似于java.util.Date類
     */

    @Test
    public void test1(){
        //now():獲取本初子午線對應的標準時間
        Instant instant = Instant.now();
        System.out.println(instant); //2021-02-10T23:35:44.312Z

        //添加時間的偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime); //2021-02-11T07:35:44.312+08:00

        //toEpochMilli():獲取自1970年1月1日0時0分0秒（UTC）開始的毫秒數 --->Date類的getTime()
        long milli = instant.toEpochMilli();
        System.out.println(milli);

        //ofEpochMilli():通過給定的毫秒數，獲取Instant實體 --->Date(long millis)
        Instant instant1 = Instant.ofEpochMilli(321321312312L);
        System.out.println(instant1);
    }
}

3.DateTimeFormatter類

代碼展示：

public class DateTimeTest {
    /*
    DateTimeFormatter:格式化或決議日期、時間
    類似于SimpleDateFormat
     */

    @Test
    public void test1(){
        //實體化方式
        //方式一：ISO_LOCAL_DATE_TIME;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);
        System.out.println(str1);
        //決議:字串--->日期
        TemporalAccessor parse = formatter.parse("2021-02-11T07:52:55.315");
        System.out.println(parse);

        //方式二：
        //本地化相關的格式，如：ofLocalizedDateTime()
        //FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :適用于LocalDateTime
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        //格式化
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);//2019年2月18日 下午03時47分16秒


        //本地化相關的格式，如：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);//2019-2-18


        //重點：方式三：自定義的格式，如：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);

        //決議
        TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
        System.out.println(accessor);

    }
}

六、Java比較器

在Java中經常會涉及到物件陣列的排序問題，那么就涉及到物件之間的比較問題，

Java實作物件排序的方式有兩種：

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

1.自然排序：Comparable介面

Comparable介面強行對實作它的每個類的物件進行整體排序，這種排序被稱為類的自然排序，

實作 Comparable 的類必須實作 compareTo(Object obj) 方法，兩個物件即通過 compareTo(Object obj) 方法的回傳值來比較大小，

實作Comparable介面的物件串列（和陣列）可以通過 Collections.sort 或Arrays.sort進行自動排序，實作此介面的物件可以用作有序映射中的鍵或有序集合中的元素，無需指定比較器，

代碼展示：

/**
 * 一、說明：java中的物件，正常情況下，只能進行比較：== 或 != ，不能使用> 或 <
 *         但是在開發場景中，我們需要對多個物件進行排序，言外之意，需要比較物件的大小
 *         如何實作？使用兩個介面中任何一個：Comparable 或 Comparator
 *
 * 二、Comparable介面的使用
 *
 */
public class CompareTest {
    /*
    Comparable介面的使用舉例：自然排序
    1.像String、包裝類等實作了Comparable介面，重寫了compareTo()，給出了比較兩個物件大小的方式
    2.像String、包裝類重寫compareTo()方法以后，進行了從小到大的排列
    3.重寫compareTo()的規則：
        如果當前物件this大于形參物件obj，則回傳正整數，
        如果當前物件this小于形參物件obj，則回傳負整數，
        如果當前物件this等于形參物件obj，則回傳零，
    4.對于自定義類來說，如果需要排序，我們可以讓自定義類實作Comparable介面，
    重寫compareTo(obj)方法，在compareTo(obj)方法中指明如何排序
     */
    @Test
    public void test1(){
        String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }


    @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));
    }
}

=================================================================
/**
 * 商品類
 */
public class Goods implements Comparable {
    private String name;
    private double price;

    //構造器、getter、setter、toString()方法略
 
    //指明商品比較大小的方式:按照價格從低到高排序,
    //再按照商品名稱從低到高排序
    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods){
            Goods goods = (Goods) o;
            //方式一：
            if (this.price > goods.price){
                return 1;
            }else if (this.price < goods.price){
                return -1;
            }else {
                //return 0;
                return this.name.compareTo(goods.name);
            }

            //方式二
            //return Double.compare(this.price,goods.price);
        }
        throw new RuntimeException("傳入的資料型別不一致!");
    }
}

2.定制排序：Comparator介面

當元素的型別沒有實作java.lang.Comparable介面而又不方便修改代碼，或者實作了java.lang.Comparable介面的排序規則不適合當前的操作，那么可以考慮使用 Comparator 的物件來排序

可以將 Comparator 傳遞給 sort 方法（如 Collections.sort 或 Arrays.sort），從而允許在排序順序上實作精確控制，
還可以使用 Comparator 來控制某些資料結構（如有序 set或有序映射）的順序，或者為那些沒有自然順序的物件 collection 提供排序，

代碼展示：

/**
 * 一、說明：java中的物件，正常情況下，只能進行比較：== 或 != ，不能使用> 或 <
 *         但是在開發場景中，我們需要對多個物件進行排序，言外之意，需要比較物件的大小
 *         如何實作？使用兩個介面中任何一個：Comparable 或 Comparator
 *
 * 二、Comparable介面與Comparator介面使用對比：
 * Comparable介面的方式一旦指定，保證該介面實作類的物件在任何位置都可以比較大小
 * Comparator介面屬于臨時性的比較
 */
public class CompareTest {
    /*
    Comparator介面的使用：定制排序
    1.背景：當元素的型別沒有實作java.lang.Comparable介面而又不方便修改代碼，
    或者實作了java.lang.Comparable介面的排序規則不適合當前的操作，那么可以考慮使用 Comparator 的物件來排序
    2.重寫compare(Object o1,Object o2)方法，比較o1和o2的大小：
    如果方法回傳正整數，則表示o1大于o2；如果回傳0，表示相等；回傳負整數，表o1小于o2，
     */

    @Test
    public void test(){
        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);
                }
                //return 0;
                throw new RuntimeException("輸入資料型別不一致");
            }
        });
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void test1(){
        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));
    }
}

七、System類

System類代表系統，系統級的很多屬性和控制方法都放置在該類的內部，該類位于java.lang包，

由于該類的構造器是private的，所以無法創建該類的物件，也就是無法實體化該類，其內部的成員變數和成員方法都是static的，所以也可以很方便的進行呼叫，

System類內部包含in、out和err三個成員變數，分別代表標準輸入流
(鍵盤輸入)，標準輸出流(顯示幕)和標準錯誤輸出流(顯示幕)，

成員方法：

1. native long currentTimeMillis()
2. void exit(int status)
3. void gc()
4. String getProperty(String key)

代碼展示：

public class SystemTest {
    @Test
    public void test(){
        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);
    }
}

輸出結果如下：
在這里插入圖片描述

八、Math類

java.lang.Math提供了一系列靜態方法用于科學計算，其方法的引數和回傳值型別一般為double型，

abs 絕對值
acos,asin,atan,cos,sin,tan 三角函式
sqrt 平方根
pow(double a,doble b) a的b次冪
log 自然對數
exp e為底指數
max(double a,double b)
min(double a,double b)
random() 回傳0.0到1.0的亂數
long round(double a) double型資料a轉換為long型（四舍五入）
toDegrees(double angrad) 弧度—>角度
toRadians(double angdeg) 角度—>弧度

九、BigInteger類

大于基本資料型別的整數，如果要表示再大的整數，不管是基本資料型別還是他們的包裝類都無能為力，更不用說進行運算了，

java.math包的BigInteger可以表示不可變的任意精度的整數，BigInteger 提供所有 Java 的基本整數運算子的對應物，并提供 java.lang.Math 的所有相關方法，另外，BigInteger 還提供以下運算：模算術、GCD 計算、質數測驗、素數生成、位操作以及一些其他操作，

構造器：
BigInteger(String val)：根據字串構建BigInteger物件

常用方法：

public BigInteger abs()：回傳此 BigInteger 的絕對值的 BigInteger
BigInteger add(BigInteger val) ：回傳其值為 (this + val) 的 BigInteger
BigInteger subtract(BigInteger val) ：回傳其值為 (this - val) 的 BigInteger
BigInteger multiply(BigInteger val) ：回傳其值為 (this * val) 的 BigInteger
BigInteger divide(BigInteger val) ：回傳其值為 (this / val) 的 BigInteger，整數相除只保留整數部分，
BigInteger remainder(BigInteger val) ：回傳其值為 (this % val) 的 BigInteger，
BigInteger[] divideAndRemainder(BigInteger val)：回傳包含 (this / val) 后跟(this % val) 的兩個 BigInteger 的陣列，
BigInteger pow(int exponent) ：回傳其值為 (thisexponent) 的 BigInteger，

十、BigDecimal類

一般的Float類和Double類可以用來做科學計算或工程計算，但在商業計算中，要求數字精度比較高，故用到java.math.BigDecimal類，

BigDecimal類支持不可變的、任意精度的有符號十進制定點數，

構造器：
public BigDecimal(double val)
public BigDecimal(String val)

常用方法：

public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode）

代碼展示：

public class SystemTest {
    @Test
    public void test(){
        BigInteger bi = new BigInteger("12421312312333241123");
        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, 15, BigDecimal.ROUND_HALF_UP));
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/258937.html

標籤：java

上一篇：封裝集合Stream常用功能,讓代碼更簡潔,不依賴任何第三方,復制即用

下一篇：Java設計模式-代理模式

Java常用類筆記

文章目錄

一、前言

二、String類

1.理解String的不可變性

2.String不同實體化方式對比

3.String不同拼接操作的對比

4.String常用方法

5.String類與其他結構之間的轉換

三、StringBuffer類和StringBuilder類

1.StringBuffer分析（StringBuilder同理）

2.StringBuffer常用方法（StringBuilder同理）

3.效率對比

四、JDK8之前日期和時間API

1.System.currentTimeMillis()

2.Date類

3.SimpleDateFormat類

4.Calendar類

五、JDK8中新日期和時間API

1. LocalDate、LocalTime、LocalDateTime

2.Instant類

3.DateTimeFormatter類

六、Java比較器

1.自然排序：Comparable介面

2.定制排序：Comparator介面

七、System類

八、Math類

九、BigInteger類

十、BigDecimal類