1. 字符串相關(guān)的類(lèi)

1.1 String的使用

String的使用

1. String聲明為final的簸搞，是不可被繼承菊碟。
2. String實(shí)現(xiàn)了Serializable接口：表示字符串是支持序列化的尖飞。實(shí)現(xiàn)了Comparable接口：表示String可以比較大小惶看。
3. String內(nèi)部定義了final char[ ] value暂论，用于存儲(chǔ)字符數(shù)據(jù)。
4. String：代表不可變的字符序列偶芍。簡(jiǎn)稱(chēng)：不可變性充择。
5. 通過(guò)字面量的方式（區(qū)別于new）給一個(gè)字符串賦值，此時(shí)的字符串值聲明在字符常量池中匪蟀。
6. 字符常量池中是不會(huì)存儲(chǔ)相同內(nèi)容的字符串的椎麦。

為什么String是不可變的字符序列

1. 當(dāng)對(duì)字符串重新賦值時(shí)，需要重寫(xiě)指定內(nèi)存區(qū)絨賦值材彪，不能使用原有的value進(jìn)行賦值观挎。
2. 當(dāng)對(duì)現(xiàn)有的字符串進(jìn)行連接操作時(shí)，也需要重新指定內(nèi)存區(qū)域賦值查刻，不能使用原有的value進(jìn)行賦值键兜。
3. 當(dāng)調(diào)用string的replace（）方法修改指定字符或字符事時(shí)凤类，也需要重新指定內(nèi)存區(qū)城賦值穗泵，不能使用原有的value進(jìn)行賦值。

1.2 String的內(nèi)存解析

String實(shí)例化內(nèi)存解析

1. 通過(guò)字面量定義的方式
2. 通過(guò)new + 構(gòu)造器的方式

import org.junit.Test;

public class StringTest {

    @Test
    public void test1(){
        //通過(guò)字面量定義的方式
        String s1 = "javaEE";
        String s2 = "javaEE";

        //通過(guò)new + 構(gòu)造器的方式
        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
    }

}

String拼接的內(nèi)存解析

1. 常量與常量的拼接結(jié)果在常量池谜疤。
2. 只要其中有一個(gè)是變量佃延，結(jié)果就在堆中。
3. 如果拼接的結(jié)果調(diào)用intern()方法夷磕，返回值就在常量池中履肃。

import org.junit.Test;

public class StringTest {
    
    @Test
    public void test2(){
        String s1 = "javaEE";
        String s2 = "hodoop";

        String s3 = "javaEEhodoop";
        //常量與常量的拼接結(jié)果在常量池
        String s4 = "javaEE" + "hodoop";
        //只要其中有一個(gè)是變量，結(jié)果就在堆中
        String s5 = s1 + "hodoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;
        //如果拼接的結(jié)果調(diào)用intern()方法坐桩，返回值就在常量池中
        String s8 = (s1 + s2).intern();

        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(s3 == s8);//true
        System.out.println(s6 == s7);//false
    }
}

1.3 String中的常用方法

常用方法1

1. int length()：返回字符串的長(zhǎng)度： return value.length尺棋。
2. char charAt(int index)：返回某索引處的字符return value[index] 。
3. boolean isEmpty()：判斷是否是空字符串：return value.length == 0 绵跷。
4. String toLowerCase()：使用默認(rèn)語(yǔ)言環(huán)境膘螟，將 String 中的所有字符轉(zhuǎn)換為小寫(xiě)。
5. String toUpperCase()：**使用默認(rèn)語(yǔ)言環(huán)境碾局，將 String 中的所有字符轉(zhuǎn)換為大寫(xiě)荆残。
6. String trim()：返回字符串的副本，忽略前導(dǎo)空白和尾部空白净当。
7. boolean equals(Object obj)：比較字符串的內(nèi)容是否相同内斯。
8. boolean equalsIgnoreCase(String anotherString)：與equals方法類(lèi)似蕴潦，忽略大小寫(xiě)。
9. String concat(String str)：將指定字符串連接到此字符串的結(jié)尾俘闯。 等價(jià)于用“+” 潭苞。
10. int compareTo(String anotherString)：比較兩個(gè)字符串的大小。
11. String substring(int beginIndex)：返回一個(gè)新的字符串真朗，它是此字符串的從beginIndex開(kāi)始截取到最后的一個(gè)子字符串萄传。
12. String substring(int beginIndex, int endIndex)：返回一個(gè)新字符串，它是此字符串從beginIndex開(kāi)始截取到endIndex(不包含)的一個(gè)子字符串蜜猾。

注意：若方法對(duì)字符串進(jìn)行修改秀菱，則必須有返回值接收新的字符串，原字符串不發(fā)生改變蹭睡。

常用方法2

1. boolean endsWith(String suffix)：測(cè)試此字符串是否以指定的后綴結(jié)束衍菱。
2. boolean startsWith(String prefix)：測(cè)試此字符串是否以指定的前綴開(kāi)始。
3. boolean startsWith(String prefix, int toffset)：測(cè)試此字符串從指定索引開(kāi)始的子字符串是否以指定前綴開(kāi)始肩豁。
4. boolean contains(CharSequence s)：當(dāng)且僅當(dāng)此字符串包含指定的char值序列時(shí)脊串，返回true。
5. int indexOf(String str)：返回指定子字符串在此字符串中第一次出現(xiàn)處的索引清钥。
6. int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出現(xiàn)處的索引琼锋，從指定的索引開(kāi)始。
7. int lastIndexOf(String str)：返回指定子字符串在此字符串中最右邊出現(xiàn)處的索引祟昭。
8. int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出現(xiàn)處的索引缕坎，從指定的索引開(kāi)始反向搜索。

注意：indexOf和lastIndexOf方法如果未找到都是返回-1篡悟。

常用方法3

1. String replace(char oldChar, char newChar)：返回一個(gè)新的字符串谜叹，它是通過(guò)用 newChar 替換此字符串中出現(xiàn)的所有 oldChar 得到的。
2. String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替換序列替換此字符串所有匹配字面值目標(biāo)序列的子字符串搬葬。
3. String replaceAll(String regex, String replacement)：使 用 給 定 的replacement 替換此字符串所有匹配給定的正則表達(dá)式的子字符串荷腊。
4. String replaceFirst(String regex, String replacement)：使 用 給 定 的replacement 替換此字符串匹配給定的正則表達(dá)式的第一個(gè)子字符串。
5. boolean matches(String regex)：告知此字符串是否匹配給定的正則表達(dá)式急凰。
6. String[] split(String regex)：根據(jù)給定正則表達(dá)式的匹配拆分此字符串女仰。
7. String[] split(String regex, int limit)：根據(jù)匹配給定的正則表達(dá)式來(lái)拆分此字符串，最多不超過(guò)limit個(gè)抡锈，如果超過(guò)了疾忍，剩下的全部都放到最后一個(gè)元素中。

1.4 String的類(lèi)型轉(zhuǎn)換

1. String與char[]之間的轉(zhuǎn)換：

   String ------> char[]：調(diào)用String的toCharArray()方法

   char[] ------> String：調(diào)用String的構(gòu)造器

   
   import org.junit.Test;
   
   public class StringTest {
       @Test
       public void test2(){
   
           //String ------> char[]：調(diào)用String的toCharArray()方法
           String str1 = "abc123";
           char[] charArray = str1.toCharArray();
   
           //char[] ------> String：調(diào)用String的構(gòu)造器
           char[] array = new char[]{'h','o','l','l','e'};
           String str2 = new String(array);
       }
   }
   

2. String與byte[]之間的轉(zhuǎn)換：

   編碼：String ------> byte[]：調(diào)用String的getBytes()方法

   解碼：byte[] ------> String：調(diào)用String的構(gòu)造器

   注意：解碼時(shí)企孩，要求解碼使用的字符集必須與編碼時(shí)使用的字符集一致锭碳，否則會(huì)出現(xiàn)亂碼。

   
   import org.junit.Test;
   
   public class StringTest {
       @Test
       public void test2(){
           String str1 = "abc123中國(guó)";
           //編碼：String ------> byte[]：調(diào)用String的getBytes()方法
           byte[] bytes = str1.getBytes();
   
           //解碼：byte[] ------> String：調(diào)用String的構(gòu)造器
           String str2 = new String(bytes);
       }
   }
   

1.5 StringBuffer與StringBuilder

String勿璃、StringBuffer擒抛、StringBuilder的異同

String：不可變字符序列推汽；底層使用char[]儲(chǔ)存

StringBuffer：可變字符序列；線(xiàn)程安全的歧沪，效率低歹撒；底層使用char[]儲(chǔ)存

StringBuilder：不可變字符序列；線(xiàn)程不安全的诊胞，效率高暖夭；底層使用char[]儲(chǔ)存

效率比較：StringBuilder > StringBuffer > String

StringBuffer與StringBuilder源碼分析

用String創(chuàng)建字符串時(shí)，有幾個(gè)字符則char[]中有幾個(gè)空間撵孤，因此不可變迈着。

用StringBuffer或StringBuilder創(chuàng)建字符串時(shí)，默認(rèn)為char[16]邪码，因此可以添加或修改裕菠。

擴(kuò)容問(wèn)題：如果要添加的數(shù)據(jù)底層數(shù)組盛不下了，那就需要擴(kuò)容底層的數(shù)組闭专。默認(rèn)情況下奴潘，擴(kuò)容為原來(lái)容量的2倍+2，同時(shí)將原有數(shù)組中的元素復(fù)制到新的數(shù)組中影钉。

StringBuffer中的常用方法

1. StringBuffer append(xxx)：提供了很多的append()方法画髓，用于進(jìn)行字符串拼接
2. StringBuffer delete(int start,int end)：刪除指定位置的內(nèi)容
3. StringBuffer replace(int start, int end, String str)：把[start,end)位置替換為str
4. StringBuffer insert(int offset, xxx)：在指定位置插入xxx
5. StringBuffer reverse() ：把當(dāng)前字符序列逆轉(zhuǎn)
6. public int indexOf(String str)：返回字符串在當(dāng)前位置首次出現(xiàn)的位置
7. public String substring(int start,int end)：返回一個(gè)從start開(kāi)始從end索引結(jié)束左閉右開(kāi)區(qū)間的子串
8. public int length()：返回字符串長(zhǎng)度
9. public char charAt(int n )：查詢(xún)指定位置的字符
10. public void setCharAt(int n ,char ch)：修改指定位置的字符

注意：StringBuilder的方法與StringBuffer的方法類(lèi)似。

2. 日期時(shí)間API

2.1 JDK8之前的時(shí)間日期API

1. java.lang.System類(lèi)

System類(lèi)提供的public static long currentTimeMillis()用來(lái)返回當(dāng)前時(shí)間與1970年1月1日0時(shí)0分0秒之間以毫秒為單位的時(shí)間差平委。

public class DataTimeTest {

    @Test
    public void test1(){
        long time = System.currentTimeMillis();
        System.out.println(time);
    }
}

2. java.util.Date類(lèi)

構(gòu)造器：Date()：使用無(wú)參構(gòu)造器創(chuàng)建的對(duì)象可以獲取本地當(dāng)前時(shí)間奈虾。Date(long date)：創(chuàng)建指定毫秒數(shù)的Data對(duì)象

常用方法：getTime()：返回自1970年1月1日00:00:00到當(dāng)前時(shí)間的毫秒數(shù)。toString()：返回當(dāng)前年肆汹、月愚墓、日、時(shí)昂勉、分、秒

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

public class DataTimeTest {
    @Test
    public void test2(){
        //構(gòu)造器一：Data():創(chuàng)建一個(gè)對(duì)應(yīng)當(dāng)前時(shí)間的Data對(duì)象
        Date date1 = new Date();
        System.out.println(date1.toString());//Sat May 30 09:20:33 CST 2020
        System.out.println(date1.getTime());//1590801633831

        //構(gòu)造器二：創(chuàng)建指定毫秒數(shù)的Dat對(duì)象
        Date date2 = new Date(902338900908L);
        System.out.println(date2.toString());//Thu Aug 06 01:41:40 CST 1998
    }
}

3. java.sql.Date類(lèi)

是java.util.Date的子類(lèi)扫腺，創(chuàng)建new Date(long time)對(duì)象

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

public class DataTimeTest {
    @Test
    public void test3(){
        java.sql.Date date3 = new java.sql.Date(3889230933908L);
        System.out.println(date3);//2093-03-30
    }
}

4. java.text.SimpleDateFormat類(lèi)

Date類(lèi)的API不易于國(guó)際化岗照，大部分被廢棄了，java.text.SimpleDateFormat類(lèi)是一個(gè)不與語(yǔ)言環(huán)境有關(guān)的方式來(lái)格式化和解析日期的具體類(lèi)笆环≡苤粒可以將日期表現(xiàn)為自己定義的格式。

兩個(gè)操作：①格式化：日期 ----> 字符串躁劣；②解析：格式化的逆過(guò)程迫吐，字符串 ----> 日期

import org.junit.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatTest {
    @Test
    public void test() throws ParseException {
        //實(shí)例化SimpleDateFormat：使用空參構(gòu)造器
        SimpleDateFormat sdf = new SimpleDateFormat();

        //格式化：日期---->字符串
        Date date = new Date();
        String format = sdf.format(date);
        System.out.println(format);//20-5-30 上午10:16

        //解析：格式化的逆過(guò)程，字符串---->日期
        //返回的日期是Date類(lèi)對(duì)象
        String str = "20-5-30 上午10:16";
        Date date1 = sdf.parse(str);
        System.out.println(date1);//Sat May 30 10:16:00 CST 2020

        //********************按照指定方式格式化和解析：調(diào)用帶參構(gòu)造器***********************

        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        //格式化
        String format1 = sdf1.format(date);
        System.out.println(format1);//2020-05-30 10:26:09
        //解析
        Date date2 = sdf1.parse("2020-05-30 10:26:09");
        System.out.println(date2);//Sat May 30 10:26:09 CST 2020


    }
}

5. java.util.Calendar(日歷)類(lèi)

Calendar是一個(gè)抽象基類(lèi)账忘，主用用于完成日期字段之間相互操作的功能志膀。

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

public class CalenderTest {
    @Test
    public void test(){

        //1.實(shí)例化
        //方式一：創(chuàng)建其子類(lèi)(GregorianCalendar)的對(duì)象熙宇，一般不使用
        //方式二：調(diào)用其靜態(tài)方法getInstance()
        Calendar calendar = Calendar.getInstance();

        //2.常用方法
        //get()
        //得到日期數(shù)據(jù)，DAY_OF_MONTH代表這個(gè)月的第幾天
        int days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);//30

        //set()
        //修改日期數(shù)據(jù)
        calendar.set(Calendar.DAY_OF_MONTH,22);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);//22

        //add()
        //給日期數(shù)據(jù)進(jìn)行增加或減小
        calendar.add(Calendar.DAY_OF_MONTH,3);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);//25

        //getTime()：日歷類(lèi)---->Date
        Date date = calendar.getTime();
        System.out.println(date);//Mon May 25 11:13:32 CST 2020

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

2.2 JDK8中的時(shí)間日期API

1. LocalDate溉浙、LocalTime烫止、LocalDateTime類(lèi)

1. LocalDateTime相較于LocalDate、LocalTime使用頻率高
2. 類(lèi)似于Calendar類(lèi)

import org.junit.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class LocalDateTimeTest {
    @Test
    public void test(){
        //now()：獲取當(dāng)前的日期戳稽、時(shí)間馆蠕、日期+時(shí)間
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println(localDate);//2020-05-31
        System.out.println(localTime);//08:53:11.057
        System.out.println(localDateTime);//2020-05-31T08:53:11.057

        //of()：設(shè)置指定的年杭棵、月彤蔽、日销凑、時(shí)彤叉、分捺球、秒吕粗。沒(méi)有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2020,10,3,8,56);
        System.out.println(localDateTime1);//2020-10-03T08:56

        //getXxx():獲取相關(guān)屬性
        System.out.println(localDateTime1.getDayOfMonth());//3
        System.out.println(localDateTime1.getMonth());//OCTOBER
        System.out.println(localDateTime1.getMinute());//56

        //設(shè)置日期時(shí)體現(xiàn)不可變性
        //withXxx():設(shè)置相關(guān)屬性
        LocalDateTime localDateTime2 = localDateTime1.withYear(2000);
        System.out.println(localDateTime1);//2020-10-03T08:56
        System.out.println(localDateTime2);//2000-10-03T08:56

        //加:體現(xiàn)不可變性
        LocalDateTime localDateTime3 = localDateTime1.plusHours(3);

        //減:體現(xiàn)不可變性
        LocalDateTime localDateTime4 = localDateTime1.minusMinutes(30);
    }
}

2. Instant類(lèi)

1. 類(lèi)似java.util.Date類(lèi)

import org.junit.Test;
import java.time.*;

public class LocalDateTimeTest {
    @Test
    public void test1(){
        //now()：獲取本初子午線(xiàn)對(duì)應(yīng)的標(biāo)準(zhǔn)時(shí)間
        Instant instant = Instant.now();
        System.out.println(instant);//2020-05-31T01:36:05.436Z

        //添加時(shí)間偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);//2020-05-31T09:36:05.436+08:00

        //toEpochMilli()：獲取自1970年1月1日0時(shí)0分0秒（UTC）開(kāi)始的毫秒數(shù) ----> Date類(lèi)的getTime()
        long milli = instant.toEpochMilli();
        System.out.println(milli);//1590888965436

        //ofEpochMilli()：適過(guò)給定的毫秒數(shù)债蜜，獲取Instant實(shí)例 ----> Date(long millis)
        Instant instant1 = Instant.ofEpochMilli(2347983749948L);
        System.out.println(instant1);//2044-05-27T17:42:29.948Z
    }
}

3. DateTimeFormatter類(lèi)

1. 類(lèi)似SimpleDateFormat類(lèi)

import org.junit.Test;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

public class LocalDateTimeTest {
    @Test
    public void test2(){
//    實(shí)例化方式一：預(yù)定義的標(biāo)準(zhǔn)格式梨州。如：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);//2020-05-31T10:41:08.201
        System.out.println(str1);//2020-05-31T10:41:08.201

        //解析：字符串 ----> 日期
        TemporalAccessor parse = formatter.parse("2020-05-31T10:41:08.201");
        System.out.println(parse);//{},ISO resolved to 2020-05-31T10:41:08.201

//    實(shí)例化方式二：本地化相關(guān)的格式祖秒。如：ofLocalizedDateTime(FormatStyle.LONG)
        //格式化：日期 ----> 字符串
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);//2020年5月31日 上午10時(shí)50分09秒

        //解析：字符串 ----> 日期
        //解碼方式與方式一類(lèi)似

//    重點(diǎn)：實(shí)例化方式三：自定義的格式诞吱。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //格式化：日期 ----> 字符串
        String str3 = formatter2.format(localDateTime);
        System.out.println(str3);//2020-05-31 10:53:11

        //解析：字符串 ----> 日期
        TemporalAccessor parse1 = formatter2.parse("2020-05-31 10:53:11");
        System.out.println(parse);//{SecondOfMinute=11, NanoOfSecond=0, HourOfAmPm=10, MicroOfSecond=0, MinuteOfHour=53, MilliOfSecond=0},ISO resolved to 2020-05-31
    }

4. 其他日期類(lèi)

3. Java比較器

3.1 自然排序：java.lang.Comparable接口

為什么要使用這兩個(gè)接口

Java中的對(duì)象，正常情況下竭缝，只能進(jìn)行比較：==或房维！=，不能使用>或<抬纸。

但是在開(kāi)發(fā)場(chǎng)景中咙俩，我們需要對(duì)多個(gè)對(duì)象進(jìn)行排序，言外之意湿故，就需要比較對(duì)象的大小阿趁。

因此我們可以使用兩個(gè)接口中的任何一個(gè)：Comparable或Comparator來(lái)進(jìn)行對(duì)象大小的比較。

非自定義類(lèi)的Comparable的使用

Comparable接口使用舉例：

1. 像String坛猪、包裝類(lèi)等實(shí)現(xiàn)了Comparable接口脖阵，重寫(xiě)了compareTo(obj)方法，給出了比較兩個(gè)對(duì)象大小的方式墅茉。
2. 像String命黔、包裝類(lèi)重寫(xiě)compareTo()方法以后，進(jìn)行了從小到大的排列就斤。
3. 重寫(xiě)compareTo(obj)的規(guī)則：
   • 如果當(dāng)前對(duì)象this大于形參對(duì)象obj悍募，則返回正整數(shù)，
   • 如果當(dāng)前對(duì)象this小于形參對(duì)象obj洋机，則返回負(fù)整數(shù)坠宴，
   • 如果當(dāng)前對(duì)象this 等于形參對(duì)象0bj，則返回零绷旗。

import org.junit.Test;
import java.lang.reflect.Array;
import java.util.Arrays;

public class CompareTest {
    @Test
    public void test(){
        String[] arr = new String[]{"AA","FF","DD","CC"};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//[AA, CC, DD, FF]
    }
}

自定義類(lèi)的Comparable的使用

對(duì)于自定義類(lèi)來(lái)說(shuō)喜鼓，如果需要排序副砍，我們可以讓自定義類(lèi)實(shí)現(xiàn)Comparable接口，重寫(xiě)compareTo(obj)颠通，在compareTo(obj)方法中指明如何排序址晕。

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

public class GoodsTest {

    @Test
    public void test(){
        Goods[] arr = new Goods[4];
        arr[0] = new Goods("xiaomi",23);
        arr[1] = new Goods("huawei",50);
        arr[2] = new Goods("applle",100);
        arr[3] = new Goods("nuojiy",60);

        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //[Goods{name='xiaomi', price=23.0}, Goods{name='huawei', price=50.0}, Goods{name='nuojiy', price=60.0}, Goods{name='applle', price=100.0}]
    }
}

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 +
                '}';
    }

    //實(shí)現(xiàn)Comparable接口中的compareTo()方法
    @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;
            }
        }
        throw new RuntimeException("傳入的數(shù)據(jù)類(lèi)型不一致");
    }
}

java中Arrays.sort為什么要有Comparable接口

Arrays.sort(Object[])我們點(diǎn)進(jìn)去可以看到有個(gè)ComparableTimSort.sort

我們?cè)冱c(diǎn)進(jìn)去sort

我們?cè)冱c(diǎn)進(jìn)去binarySort

現(xiàn)在我們有了答案，就是用接口定義變量來(lái)強(qiáng)轉(zhuǎn)后引用這個(gè)數(shù)組顿锰，這樣不管Objcet實(shí)際是什么類(lèi)型的谨垃，都可以使用接口中定義的方法。

實(shí)現(xiàn)Comparable接口的對(duì)象列表（和數(shù)組）可以通過(guò) Collections.sort或Arrays.sort進(jìn)行自動(dòng)排序硼控。

3.2 定制排序：java.util.Comparator接口

Comparator的使用

出現(xiàn)背景：當(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)排序牢撼。

重寫(xiě)方式：重寫(xiě)compare(Object o1,Object o2)方法匙隔，比較o1和o2的大小：如果方法返回正整數(shù)熏版，則表示o1大于o2纷责；如果返回0，表示相等撼短；返回負(fù)整數(shù)再膳，表示o1小于o2。

排序機(jī)制：Comparator 傳遞給 sort 方法（如 Collections.sort 或 Arrays.sort）曲横，從而允許在排序順序上實(shí)現(xiàn)精確控制喂柒。

public class ComparatorTest {

        @Test
        public void test(){
            String[] arr = new String[]{"AA","FF","DD","CC"};
            Arrays.sort(arr, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    if(o1 instanceof String && o2 instanceof String){
                        String s1 = (String) o1;
                        String s2 = (String) o2;
                        return -s1.compareTo(s2);
                    }
                    throw new RuntimeException("輸入的數(shù)據(jù)不一樣");
                }
            });
            System.out.println(Arrays.toString(arr));//[FF, DD, CC, AA]
        }

}

3.3 兩個(gè)接口的比較

Comparable接口的方式一旦實(shí)現(xiàn)，保證Comparable接口實(shí)現(xiàn)類(lèi)的對(duì)象在任何位置都可以比較大小禾嫉，可以多次使用灾杰。

Comparator接口屬于臨時(shí)性的比較，每次比較都需要重新傳遞參數(shù)熙参，重寫(xiě)方法艳吠。

4. System類(lèi)

System類(lèi)介紹

System類(lèi)代表系統(tǒng)，系統(tǒng)級(jí)的很多屬性和控制方法都放置在該類(lèi)的內(nèi)部尊惰。該類(lèi)位于java.lang包讲竿。

由于該類(lèi)的構(gòu)造器是private的，所以無(wú)法創(chuàng)建該類(lèi)的對(duì)象弄屡，也就是無(wú)法實(shí)例化該類(lèi)。其內(nèi)部的成員變量和成員方法都是static的鞋诗，所以也可以很方便的進(jìn)行調(diào)用膀捷。

System類(lèi)成員介紹

5. Math類(lèi)

java.lang.Math提供了一系列靜態(tài)方法用于科學(xué)計(jì)算。其方法的參數(shù)和返回值類(lèi)型一般為double型削彬。

6. BigInteger與BigDecimal

6.1 BigInteger類(lèi)

Integer類(lèi)作為int的包裝類(lèi)全庸，能存儲(chǔ)的最大整型值為2 31-1秀仲，Long類(lèi)也是有限的，最大為2 63-1壶笼。如果要表示再大的整數(shù)神僵，不管是基本數(shù)據(jù)類(lèi)型還是他們的包裝類(lèi)都無(wú)能為力，更不用說(shuō)進(jìn)行運(yùn)算了覆劈。

java.math包的BigInteger可以表示不可變的任意精度的整數(shù)保礼。BigInteger 提供所有 Java 的基本整數(shù)操作符的對(duì)應(yīng)物，并提供 java.lang.Math 的所有相關(guān)方法责语。

6.2 BigDecimal類(lèi)

一般的Float類(lèi)和Double類(lèi)可以用來(lái)做科學(xué)計(jì)算或工程計(jì)算炮障，但在商業(yè)計(jì)算中，要求數(shù)字精度比較高坤候，故用到j(luò)ava.math.BigDecimal類(lèi)胁赢。

BigDecimal類(lèi)支持不可變的、任意精度的有符號(hào)十進(jìn)制定點(diǎn)數(shù)白筹。