集合框架使用集合做什么集合的分類具體的實(shí)現(xiàn)類ListArrayListLinkedListSetTreeSetMapHashMapTreeMap數(shù)組、List、Set、Map的數(shù)據(jù)轉(zhuǎn)換數(shù)組轉(zhuǎn) List數(shù)組和Set從Map中得到Set和List散列表（哈希表）的基本原理散列表是如何根據(jù)Key來快速找到它所匹配的 Value 呢 ？散列表的讀寫操作寫操作（put）讀操作（get）IteratorCollections排序查找排序List 集合排序TreeMap 排序自定義類排序外部指定排序本身擁有排序

集合框架

程序開發(fā)并不是解決了業(yè)務(wù)的基本功能就完成了，很多時候程序運(yùn)行的環(huán)境是有限制的。比如內(nèi)存小，CPU頻率低，或者是像手機(jī)這樣的設(shè)備，能源供應(yīng)有限。在這種環(huán)境下，就需要程序能夠在有限的環(huán)境中提升效率。這就需要使用數(shù)據(jù)結(jié)構(gòu)和算法。

但是數(shù)據(jù)結(jié)構(gòu)與算法即便是學(xué)過，也未必在工作時能夠用好，而且通用性、性能等等也都是問題。加上學(xué)習(xí)程序開發(fā)的受眾群體越來越廣，讓程序員全部自己實(shí)現(xiàn)數(shù)據(jù)結(jié)構(gòu)與算法不是一個好的主意。所以現(xiàn)在很多語言為了能夠提升學(xué)習(xí)效率，降低學(xué)習(xí)門檻，同時也為了讓程序有更好的執(zhí)行效率和通用性，就自帶了各種實(shí)現(xiàn)了數(shù)據(jù)結(jié)構(gòu)與算法的API集合。在Java中，這就是我們現(xiàn)在要學(xué)習(xí)的「集合框架」

與現(xiàn)在常見到的數(shù)據(jù)結(jié)構(gòu)類庫一樣，Java也是將集合類庫的接口（interface）與實(shí)現(xiàn)（implementation）分離。所以我們的學(xué)習(xí)方式一般都是先搞明白接口的分類和關(guān)系，然后根據(jù)不同的接口來學(xué)習(xí)對應(yīng)的實(shí)現(xiàn)類。

使用集合做什么

1. 搬運(yùn)數(shù)據(jù)，集合可以存儲數(shù)據(jù)，然后通過API調(diào)用很方便就可以傳遞大量數(shù)據(jù)

2. 數(shù)據(jù)處理，集合中可以直接對數(shù)據(jù)進(jìn)行操作，比如統(tǒng)計(jì)、去重

3. 排序，可以將數(shù)據(jù)按照需求進(jìn)行各種排序，然后再傳遞給調(diào)用者

集合的分類

image-20200212141927241.png

Java的集合從 Collection 接口和 Map 接口入手

Map 接口和 Collection 沒有交集，它有自己的方式，只要標(biāo)準(zhǔn)庫后綴不是Map 結(jié)尾的，都是直接或者間接實(shí)現(xiàn)了Collection接口。

Collection 接口中常見的操作是數(shù)據(jù)的添加、刪除

1. add / addAll

2. remove / removeAll / removeIf

借助 Iterator 接口，Collection 還具備了數(shù)據(jù)的循環(huán)

public interface Collection<E> extends Iterable<E>{
//...
// 對數(shù)據(jù)循環(huán)
Iterator<E> iterator();
}

通過 Iterable 接口， 標(biāo)準(zhǔn)庫中的集合都可以使用 forEach 循環(huán)。

具體的實(shí)現(xiàn)類

Collection

image-20200212145950872.png

Map

image-20200212150240334.png

雖然類很多 ，但是我們在教授中只需要交幾個類就可以了，分別是下面：

1. ArrayList

2. LinkedList

3. HashSet

4. HashMap

5. TreeMap

然后加上工具類2個：

1. Collections

2. Arrays

List

有序集合，可以精確控制列表中每個元素的插入位置。通過整數(shù)索引獲取列表中的元素。List允許出現(xiàn)重復(fù)的值 ， 并可以精確控制列表中每個元素的插入位置，通過整數(shù)索引獲取列表中的元素。

ArrayList

ArrayList 是List 接口的大小可變數(shù)組的實(shí)現(xiàn)。實(shí)現(xiàn)了所有可選列表操作， 并允許包括null 在內(nèi)的所有元素。除了實(shí)現(xiàn)List 接口外， 此類還提供一些方法來操作內(nèi)部用來存儲列表的數(shù)組的大?。?此類大致上等同于 vector 類， 但 vector 是同步的） 。

ArrayList 的底層是使用數(shù)組實(shí)現(xiàn)的，看下面的圖

image-20200212171434134.png

可以看到，數(shù)組中的每一個元素，都存儲在內(nèi)存單元中，并且元素之間緊密排列，既不能打亂元素的存儲順序，也不能跳過某個存儲單元進(jìn)行存儲。

ArrayList 底層既然是使用數(shù)組實(shí)現(xiàn)，那么特點(diǎn)就和數(shù)組一致：查詢速度快，增刪速度慢。

每個ArrayList 實(shí)例都有一個容量。該容量是指用來存儲列表元素的數(shù)組的大小， 它總是至少等于列表的大小。隨著向Array L ist 中小斷添加元素， 其容量也自動增長。并未指定增長策略的細(xì)節(jié)，因?yàn)檫@不只是添加元素會帶來分?jǐn)偣潭〞r間開銷那樣簡單。我們可以使用默認(rèn)構(gòu)造函數(shù)創(chuàng)建容量為 10 的列表， 也可以初始化指定容量大小。

ArrayList 指定初始容量大小的構(gòu)造器方法

public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
}
}

常用的操作

public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();

    //  添加數(shù)據(jù)
    list.add(123);
    list.add(346);

    //  替換數(shù)據(jù)
    list.set(1, 777);

    //  將list中的所有數(shù)據(jù)放到 list2 中
    List<Integer> list2 = new ArrayList<>();
    list2.addAll( list );

    //  循環(huán)list2中所有的數(shù)據(jù)
    for (Integer integer : list2) {

        System.out.println( integer );

        //  刪除循環(huán)出的對象
        list2.remove(integer);
    }

    //  list 集合是否有數(shù)據(jù)
    if( !list.isEmpty() ) {

        System.out.println("list.size = "+ list.size());

        //  清空 list
        list.clear();
    }

    //  在清空list后，再看list現(xiàn)在有多少數(shù)據(jù)
    System.out.println("list.size = "+ list.size());
}

}

LinkedList

LinkedList 是一個鏈表結(jié)構(gòu)，可當(dāng)作堆棧、隊(duì)列、雙端隊(duì)列 。鏈表是一種在物理上非連續(xù)、非順序的數(shù)據(jù)結(jié)構(gòu)，由若干節(jié)點(diǎn)（node）所組成。

單鏈表

image-20200212173413313.png

單向鏈表的每一個節(jié)點(diǎn)包含兩部分，一部分是存放數(shù)據(jù)的變量data，另一部分是指向下一個節(jié)點(diǎn)的指針next。正如地下黨的聯(lián)絡(luò)方式，一級一級，單線傳遞：
private static class Node {
int data;
Node next;
}

雙鏈表

雙向鏈表比單向鏈表稍微復(fù)雜一些，它的每一個節(jié)點(diǎn)除了擁有data和next指針，還擁有指向前置節(jié)點(diǎn)的prev指針

image-20200212173517719.png

和數(shù)組不同，鏈表存儲數(shù)據(jù)的時候，則采用了見縫插針的方式，鏈表的每一個節(jié)點(diǎn)分布在內(nèi)存的不同位置，依靠next指針關(guān)聯(lián)起來。這樣可以靈活有效地利用零散的碎片空間。

image-20200212173548104.png

LinkedList 做數(shù)據(jù)的添加和刪除操作時速度很快，但是做查詢的時候速度就很慢，這和 ArrayList 剛好相反。

適用 LinkedList 獨(dú)有的方法，在集合前后做數(shù)據(jù)插入

public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();

    list.add(123);
    //  添加相同的數(shù)據(jù)
    list.add(123);
    list.add(456);
    list.add(789);
    list.add(101);

    //  將數(shù)據(jù) 111 添加到 list 的末尾
    list.addLast(111);
    //  將數(shù)據(jù) 999 添加到 list的最前面
    list.addFirst(999);

    for (int i = 0; i < list.size(); i++) {
        System.out.println( list.get(i) );
    }

}

注意代碼中聲明和實(shí)現(xiàn)都是 LinkedList ， 如果聲明的是 List 接口 ， addFirst 和 addLast 方法是不可見的

Set

Set 的特點(diǎn)是去重，如果相同的數(shù)據(jù)只會保留一個。集合內(nèi)的數(shù)據(jù)是一個無序的狀態(tài)，。當(dāng)然也有例外，TreeSet就是有序的。

可以看到，Set 和 List 中的方法都是相同的，作用也一致。但是 Set 是沒有直接獲取數(shù)據(jù)的方法。我們更多的時候使用的是 List 和 Map。

Has hSet 由哈希表（ 實(shí)際上是一個HashM ap 實(shí)例） 支持， 為基木操作提供了穩(wěn)定性能， 這些基本操作包括add() 、remove() 、contains() 和size() ， 假定哈希函數(shù)將這些元素正確地分布在桶中。對此 set() 進(jìn)行迭代所需的時間與HashSet 實(shí)例的大小（ 元素的數(shù)量） 和底層HashMap 實(shí)例（ 桶的數(shù)量）的“ 容量” 的和成比例。因此， 如果迭代性能很重要， 則不要將初始容量沒置得太高（ 或?qū)⒓虞d因了設(shè)置得太低） 。

public static void main(String[] args) {

HashSet set = new HashSet<>();
    
set.add( new Object() );
set.add( new Object() );
set.add( "hello" );
set.add( "hello" );
set.add( "你好" );
set.add( 123 );
set.add( 123 );
set.add( 234 );
set.remove("你好");
set.remove( new Object() );
for (Object object : set) {
    System.out.println( object );
}

}

以上代碼經(jīng)輸出可以看到：輸出的內(nèi)容沒有按照輸入時的順序進(jìn)行輸出。

李四
8890
張三
azxcv
ABC

TreeSet

Set 集合中的另類，存儲的數(shù)據(jù)時有序的
package com.company;

import java.util.TreeSet;

public class Main {
public static void main(String[] args) {
TreeSet<String> set = new TreeSet<>();
set.add("8890");
set.add("123");
set.add("張三");
set.add("李四");
set.add("ABC");
set.add("azxcv");

    for (String string : set) {
        System.out.println(string);
    }

}

}

輸出的結(jié)果：

8890
ABC
azxcv
張三
李四</pre>

可以發(fā)現(xiàn)數(shù)據(jù)是按照數(shù)字、大寫字母、小寫字母、漢字進(jìn)行排序的，但是漢字相關(guān)的數(shù)據(jù)本身沒有排序，可以嘗試將李四放在張三的數(shù)據(jù)上面看輸出的結(jié)果。

Map

Map 是一種把鍵對象和值對象進(jìn)行關(guān)聯(lián)的容器， 而一個值對象又可以是一個Map, 依次類推，這樣就可形成一個多級映射。

想想學(xué)習(xí)英語使用的詞典軟件，輸入英文（key）后，軟件會顯示出對應(yīng)的中文（value）。Map就是在內(nèi)存中的這種結(jié)構(gòu)。

Key（鍵）：

1. 和 set— 樣，鍵對象不允許重復(fù)，這是為了保持查找結(jié)果的一致性。 如果有兩個鍵對象一樣， 那你想得到那個鍵對象所對應(yīng)的值對象時就有問題了。

2. 在使用過程中某個鍵所對應(yīng)的值對象可能會發(fā)生變化， 這時會按照最后一次修改的值對象與鍵對應(yīng)（就是key同一個key有多次值綁定，最后一個就會覆蓋之前的）

3. 可以使用 null 作為 Key

Value（值）:

1. 值對象沒有唯一性的要求， 你可以將任意多個鍵都映射到一個值對象上， 這不會發(fā)生任何問題（ 不過對使用卻可能會造成不便， 你不知道你得到的到底是那一個鍵所對應(yīng)的值對象，所以請不要這樣做）

2. 可以使用 null 作為 Value

Map 有兩種比較常用的實(shí)現(xiàn)： HashMap 和 TreeMap

常用的方法

HashMap

HashMap 用到了哈希碼的算法， 以便快速查找一個鍵。

public static void main(String[] args) {

    HashMap<String, String> zsInfo = new HashMap<>();

    zsInfo.put("name", "張三");
    zsInfo.put("height", "173CM");
    zsInfo.put("sex", "男性");

    for (Map.Entry<String, String> info : zsInfo.entrySet()) {
        System.out.println( info );
    }
}

TreeMap

TreeMap 是對鍵按序存放， 因此它便有一些擴(kuò)展的方法， 比如 firstKey() 、lastKey() 等， 可以從TreeMap 中指定一個范圍以取得其子Map

public static void main(String[] args) {

TreeMap<String, String> tree = new TreeMap<>();

tree.put("name", "Jack");
tree.put("age", "22");
tree.put("身高", "173");
tree.put("sex", "man");
tree.put("體重", "70KG");

System.out.println("-------------------");
for (Map.Entry<String, String> entry : tree.entrySet()) {
    System.out.println( entry );
}
System.out.println("-------------------");

System.out.println("firstKey = "+ tree.firstKey());
System.out.println("firstEntry = "+ tree.firstEntry());
System.out.println("lastKey = "+ tree.lastKey());
System.out.println("lastEntry = "+ tree.lastEntry());

數(shù)組、List、Set、Map的數(shù)據(jù)轉(zhuǎn)換

不同類型的集合相互轉(zhuǎn)換在程序開發(fā)中都是非常常見的 API 操作，這些基礎(chǔ)操作一定要熟悉。

數(shù)組轉(zhuǎn) List

/*
* 數(shù)組轉(zhuǎn)List，但是這里要注意，Arrays.asList方法轉(zhuǎn)出來的雖然也叫ArrayList，
* 但不是java.util.ArrayList，而是Arrays中的一個內(nèi)部類ArrayList。兩者之間并不相等。
* 內(nèi)部類ArrayList沒有實(shí)現(xiàn)remove、add等方法，使用的話會報(bào)錯。
*/
System.out.println("使用Arrays.asList將數(shù)組轉(zhuǎn)換為List--------------------------------");
String str[] = { "中文", "計(jì)算機(jī)", "ABC", "123", "qq@qq.com" };

List<String> strList = Arrays.asList(str);

for (String string : strList) {
System.out.println(string);
}

System.out.println("使用ArrayList構(gòu)造器方式再由Arrays.asList將數(shù)組轉(zhuǎn)換為List----------");
// 使用下面的代碼的寫法就不會有問題了。
ArrayList<String> stringsList = new ArrayList<String>(Arrays.asList(str));
// 使用remove方法
stringsList.remove(3);

for (String string : stringsList) {
System.out.println(string);
}

System.out.println("使用List.toArray方法將一個List轉(zhuǎn)換為數(shù)組(默認(rèn)為Object數(shù)組)----------");
Object[] strArr = stringsList.toArray();
for (Object object : strArr) {
System.out.println(object.toString());
}

數(shù)組和Set

System.out.println("使用Arrays.asList將數(shù)組轉(zhuǎn)換為List--------------------------------");
String str[] = { "中文", "計(jì)算機(jī)", "ABC", "123", "qq@qq.com" };

System.out.println("下面是數(shù)組轉(zhuǎn)Set ----------------------------------");

Set<String> strSet = new HashSet<String>(Arrays.asList(str));
for (String string : strSet) {
System.out.println(string);
}
System.out.println("下面是將Set集合轉(zhuǎn)換為數(shù)組-------------");
Object[] objArr = strSet.toArray();
for (Object string : objArr) {
System.out.println(string);
}

從Map中得到Set和List

Map<String, String> map = new HashMap<String, String>();
map.put("1", "A");
map.put("2", "B");
map.put("3", "C");

// 輸出所有的key , keySet()方法其實(shí)返回的就是一個Set集合。
System.out.println("通過keySet輸出所有的key：" + map.keySet());

// 把map的值轉(zhuǎn)為一個List
List<String> stringList = new LinkedList<String>(map.values());
for (String string : stringList) {
System.out.print(string + " ");
}

散列表（哈希表）的基本原理

上面 HashSet 和 HashMap 都使用了 散列表來做數(shù)據(jù)的檢索，那么什么是散列表 ，這個又有什么優(yōu)點(diǎn)呢 ？

散列表也叫作哈希表（hash table），這種數(shù)據(jù)結(jié)構(gòu)提供了鍵（Key）和值（Value）的映射關(guān)系。只要給出一個Key，就可以高效查找到它所匹配的Value，時間復(fù)雜度接近于O(1)。

是不是想到了 Map ？

散列表是如何根據(jù)Key來快速找到它所匹配的 Value 呢 ？

在目前所學(xué)的數(shù)據(jù)結(jié)構(gòu)中，數(shù)組的查詢效率是最高的。散列表本質(zhì)就是一個數(shù)組。不同的是數(shù)組的下標(biāo)是數(shù)字，但是散列表的下標(biāo)是字符串。這就需要設(shè)計(jì)一個中轉(zhuǎn)站，通過某種方式，把Key和數(shù)組下標(biāo)進(jìn)行轉(zhuǎn)換。這個中轉(zhuǎn)站就叫作哈希函數(shù)。

image-20200213110338179.png

在不同的語言中，哈希函數(shù)的實(shí)現(xiàn)是不一樣的。我們以Java的HashMap為例，來看看哈希函數(shù)的實(shí)現(xiàn)。

在Java及大多數(shù)面向?qū)ο蟮恼Z言中，每一個對象都有屬于自己的hashcode，這個hashcode是區(qū)分不同對象的重要標(biāo)識。無論對象自身的類型是什么，它們的hashcode都是一個整型變量。
既然都是整型變量，想要轉(zhuǎn)化成數(shù)組的下標(biāo)也就不難實(shí)現(xiàn)了。最簡單的轉(zhuǎn)化方式是什么呢？是按照數(shù)組長度進(jìn)行取模運(yùn)算

index = HashCode (Key) % Array.length

其實(shí)JDK中的哈希函數(shù)為了提升效率，使用的是位運(yùn)算。我們就假設(shè)使用的是模運(yùn)算

通過哈希函數(shù)，我們可以把字符串或其他類型的Key，轉(zhuǎn)化成數(shù)組的下標(biāo)index。如給出一個長度為8的數(shù)組，則當(dāng) key=001121時
index = HashCode ("001121") % Array.length = 1420036703 % 8 = 7

而當(dāng)key=this時，
index = HashCode ("this") % Array.length = 3559070 % 8 = 6

散列表的讀寫操作

有了哈希函數(shù)，就可以在散列表中進(jìn)行讀寫操作了。

寫操作（put）

寫操作就是在散列表中插入新的鍵值對（在JDK中叫作Entry）。如調(diào)用hashMap.put("002931", "王五")，意思是插入一組Key為002931、Value為王五的鍵值對。具體該怎么做呢？

1. 通過哈希函數(shù)，把Key轉(zhuǎn)化成數(shù)組下標(biāo)5。

2. 如果數(shù)組下標(biāo)5對應(yīng)的位置沒有元素，就把這個Entry填充到數(shù)組下標(biāo)5的位置

image-20200213111520051.png

由于數(shù)組的長度是有限的，當(dāng)插入的Entry越來越多時，不同的Key通過哈希函數(shù)獲得的下標(biāo)有可能是相同的。例如002936這個Key對應(yīng)的數(shù)組下標(biāo)是2；002947這個Key對應(yīng)的數(shù)組下標(biāo)也是2。

![image-20200213111552721.png](https://upload-images.jianshu.io/upload_images/25694282-1cf7aa13117fdd9b.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

這種情況，就叫作哈希沖突

解決哈希沖突的方法主要有兩種，一種是開放尋址法，一種是鏈表法

1. 開放尋址法的原理很簡單，當(dāng)一個Key通過哈希函數(shù)獲得對應(yīng)的數(shù)組下標(biāo)已被占用時，我們可以“另謀高就”，尋找下一個空檔位置

2. HashMap數(shù)組的每一個元素不僅是一個Entry對象，還是一個鏈表的頭節(jié)點(diǎn)。每一個Entry對象通過next指針指向它的下一個Entry節(jié)點(diǎn)。當(dāng)新來的Entry映射到與之沖突的數(shù)組位置時，只需要插入到對應(yīng)的鏈表中即可

image-20200213111821959.png

讀操作（get）

讀操作就是通過給定的Key，在散列表中查找對應(yīng)的Value。例如調(diào)用 hashMap.get("002936")，意思是查找Key為002936的Entry在散列表中所對應(yīng)的值

1. 通過哈希函數(shù)，把Key轉(zhuǎn)化成數(shù)組下標(biāo)2。

2. 找到數(shù)組下標(biāo)2所對應(yīng)的元素，如果這個元素的Key是002936，那么就找到了；如果這個Key不是002936也沒關(guān)系，由于數(shù)組的每個元素都與一個鏈表對應(yīng)，我們可以順著鏈表慢慢往下找，看看能否找到與Key相匹配的節(jié)點(diǎn)。

Iterator

iterator是為了實(shí)現(xiàn)對Java容器（collection）進(jìn)行遍歷功能的一個接口。 在iterator實(shí)現(xiàn)了Iterator接口后，相當(dāng)于把一個Collection容器的所有對象，做成一個線性表（List），而iterator本身是一個指針，開始時位于第一個元素之前。

遍歷1個ArrayList 和Linklist是十分容易的，遍歷1個Tree容器也不難，但是實(shí)現(xiàn)機(jī)制是完全不同，而遍歷1個Set容器就無從下手了。 Iterator 這個接口讓各種容器自己去重寫里面的hasNext()和next()方法。 不用關(guān)心各種容器的遍歷機(jī)制，只要使用Iterator，會讓人覺得各種容器的遍歷方法都是一樣的，這就是Java接口的重要意義。

HashMap zsInfo = new HashMap<>();

zsInfo.put("name", "張三");
zsInfo.put("height", "173CM");
zsInfo.put("sex", "男性");
zsInfo.put("skin-color", "白色");

zsInfo.put("height", "183CM");
zsInfo.remove("skin-color");

System.out.println("Iterator 循環(huán)------------------");
Iterator iterator = zsInfo.entrySet().iterator();

while( iterator.hasNext() ) {
Map.Entry next = (Entry) iterator.next();
System.out.println( next );
}

Collections

Collections 是 Java 提供對Set 、List 和Map 等集合操作的工具類。

該工具類里提供了大量方法，除了對集合元素進(jìn)行排序、查詢和修改等操作；還提供了將集合對象設(shè)置為不可變、對集合對象實(shí)現(xiàn)同步控制等方法。

排序

ArrayList nums = new ArrayList<>();
nums.add(2);
nums.add(0);
nums.add(-5);
nums.add(0);
nums.add(3);
System.out.println( nums );
Collections.reverse( nums );
System.out.println( nums);

Collections.sort( nums );
System.out.println( nums );

Collections.shuffle( nums );
System.out.println( nums );

查找

ArrayList nums = new ArrayList<>();
nums.add(2);
nums.add(0);
nums.add(-5);
nums.add(0);
nums.add(3);
System.out.println( nums );

System.out.println( Collections.max( nums ));
System.out.println( Collections.min( nums ));
Collections.replaceAll(nums, 0 , 1);
System.out.println( nums );

System.out.println( Collections.frequency(nums, 1));

Collections.sort(nums);
System.out.println( nums );

System.out.println( Collections.binarySearch(nums, 3 ));

排序

集合的排序有2種方式：

1. 集合內(nèi)部就擁有排序的能力。

   需要排序的能力的類實(shí)現(xiàn) Comparable 接口的方法

2. 集合本身沒有排序的能力，可以通過外部指定排序的方式。

   在排序方法中，指定一個實(shí)現(xiàn)了 Comparator 接口的類的對象

Comparable是需要比較的對象來實(shí)現(xiàn)接口。這樣對象調(diào)用實(shí)現(xiàn)的方法來比較。對對象的耦合度高（需要改變對象的內(nèi)部結(jié)構(gòu)，破壞性大）。

Comparator相當(dāng)于一通用的比較工具類接口。需要定制一個比較類去實(shí)現(xiàn)它，重寫里面的compare方法，方法的參數(shù)即是需要比較的對象。對象不用做任何改變，解耦。

List 集合排序

List<Integer> list = new ArrayList<Integer>();

list.add(123);
list.add(999);
list.add(101);
list.add(33);
list.add(76);

Collections.sort(list);

for (Integer integer : list) {
System.out.println( integer );
}

直接就可以得到自然升序，我們在上面的代碼中沒有看到任何接口，原因是List集合中的 Integer 類本身就實(shí)現(xiàn)了 Comparable 接口

public final class Integer extends Number implements Comparable<Integer> {
//...
}

TreeMap 排序

treeMap 的示例中，我們使用了外部指定排序方式：Comparator

TreeMap<String, String> tree = new TreeMap<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1) ; //
}
});

tree.put("name", "Jack");
tree.put("age", "22");
tree.put("身高", "173");
tree.put("sex", "man");
tree.put("體重", "70KG");

System.out.println("-------------------");
for (Map.Entry<String, String> entry : tree.entrySet()) {
System.out.println( entry );
}

自定義類排序

當(dāng)我們自定義了一個類，也希望能夠進(jìn)行排序的話，就需要實(shí)現(xiàn) Comparator接口或者是 Comparable 接口了。

public class User {
private Integer uid;
private String uname;
//....
}

外部指定排序

User 類沒有實(shí)現(xiàn) Comparable 接口，通過 Collections 工具類的 sort 方法進(jìn)行排序，在 sort 方法的第二個參數(shù)上指定排序的規(guī)則

List<User> list = new ArrayList<User>();

list.add( new User(110 ,"Mark") );
list.add( new User(101 ,"李四") );
list.add( new User(100 ,"張三") );
list.add( new User(111 ,"Jack") );

// Comparator 接口因?yàn)槭峭獠颗判颍孕枰缹Ρ鹊?個對象
Collections.sort(list , new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
return o2.getUid() - o1.getUid() ;
}
});

for (User user : list) {
System.out.println( user );
}

本身擁有排序

因?yàn)槭莾?nèi)部排序，所以只需要傳入被排序的對象即可，另一個排序?qū)ο螽?dāng)然是對象本身，使用 this 指向即可。

public class User implements Comparable<User> {

private Integer uid;
private String uname;

public User(int i, String string) {
    this.uid = i;
    this.uname = string;
}

@Override
public int compareTo(User o) {
    return this.getUid() - o.getUid() ;
}

public Integer getUid() {
    return uid;
}

public void setUid(Integer uid) {
    this.uid = uid;
}

public String getUname() {
    return uname;
}

public void setUname(String uname) {
    this.uname = uname;
}

@Override
public String toString() {
    return "User [uid=" + uid + ", uname=" + uname + "]";
}

}

排序
List<User> list = new ArrayList<User>();

list.add( new User(110 ,"Mark") );
list.add( new User(101 ,"李四") );
list.add( new User(100 ,"張三") );
list.add( new User(111 ,"Jack") );

Collections.sort(list);

for (User user : list) {
System.out.println( user );
}

輸出結(jié)果

User [uid=100, uname=張三]
User [uid=101, uname=李四]
User [uid=110, uname=Mark]
User [uid=111, uname=Jack]