集合框架

程序開發(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)計、去重

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

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 是同步的） 稚虎。

image-20200212171434134.png

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

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

每個ArrayList 實(shí)例都有一個容量梦染。該容量是指用來存儲列表元素的數(shù)組的大小， 它總是至少等于列表的大小朴皆。隨著向Array L ist 中小斷添加元素帕识， 其容量也自動增長。并未指定增長策略的細(xì)節(jié)遂铡，因為這不只是添加元素會帶來分?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());
}

    DEFAULT_CAPACITY = 10   默認(rèn)容量 = 10  初始化容量
    

LinkedList

LinkedList 是一個鏈表結(jié)構(gòu)，可當(dāng)作堆棧钾怔、隊列碱呼、雙端隊列 。鏈表是一種在物理上非連續(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

image-20200212173548104.png

適用 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ù)時有序的

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é)果：

123
8890
ABC
azxcv
張三
李四

可以發(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 );
    }
}
    DEFAULT_INITIAL_CAPACITY = 1 << 4   默認(rèn)的初始化容量 = 2^4 =16
    aka: Also Known As  也被稱作
    DEFAULT_LOAD_FACTOR = 0.75f 默認(rèn)加載因子 = 0.75 = 75%
    TREEIFY_THRESHOLD = 8       樹化_閾值 = 8 

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等方法审磁，使用的話會報錯。
 */
System.out.println("使用Arrays.asList將數(shù)組轉(zhuǎn)換為List--------------------------------");
String str[] = { "中文", "計算機(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ī)", "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è)計一個中轉(zhuǎn)站，通過某種方式钉嘹，把Key和數(shù)組下標(biāo)進(jìn)行轉(zhuǎn)換鸯乃。這個中轉(zhuǎn)站就叫作哈希函數(shù)。

image-20200213110338179.png

在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
   
   這種情況褪储，就叫作哈希沖突

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

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 接口因為是外部排序状原，所以需要知道對比的2個對象
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 );
}

本身擁有排序

因為是內(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]