文章目錄

Demo13-集合（Set、Collections、Map、集合嵌套）
- 1.Set集合
- - 1.1Set系列集合特點:
  - 1.2HashSet元素無序的底層原理
  - 1.3HashSet元素去重複的底層原理
  - 1.4LinkedHashSet
  - 1.5TreeSet
  - 1.6Collection體系使用場景
- 2.可變參數
- 3.Collections工具類
- 4.Map集合
- - 4.1Map集合概述
  - 4.2Map集合體系
  - 4.3Map集合常用API
  - 4.4Map集合的周遊方式
  - - 4.4.1周遊方式一:鍵找值
    - 4.4.2周遊方式二:鍵值對
    - 4.4.2周遊方式三:Lambda表達式
  - 4.5集合案例
  - 4.6HashMap集合
  - 4.7LinkedHashMap集合
  - 4.8TreeMap集合
  - 4.9集合嵌套案例

Demo13-集合（Set、Collections、Map、集合嵌套）

1.Set集合

1.1Set系列集合特點:

無序:存取順序不一緻
不重複:可以去除重複
無索引:底層實作是有索引的,但是因為Set集合的特殊性,沒有對外公開索引,是以就沒有帶索引的方法,是以不能使用普通for循環周遊,也不能通過索引來擷取元素

Set:

HashSet:無序,不重複無索引
- LinkedHashSet:有序,不重複,無索引(有序指的是保證存儲和取出的元素順序一緻)
TreeSet:排序,不重複,無索引

Set集合的功能上基本上與Collection的API一緻

1.2HashSet元素無序的底層原理

HashSet集合底層采取哈希表存儲資料,哈希表是一種對于增删改查資料性能都較好的結構
哈希表的組成:
- JDK8之前,底層使用數組+連結清單組成
- JDK8之後,底層采用數組+連結清單+紅黑樹組成
在了解哈希表之前需要先了解哈希值的概念
- 哈希值是JDK根據對象的位址,按照某種規則算出來的int類型的數值
- 通過Object類的API傳回對象的哈希值:public int hashCode();
- 對象的哈希值特點:
  - 同一個對象多次調用hashCode()方法傳回的哈希值是相同的
  - 預設情況下,不同對象的哈希值是不同的

1.HashSet1.7版本原了解析:數組+連結清單(結合雜湊演算法)

建立一個預設長度為16的數組,數組名為table
根據元素的哈希值跟數組的長度求餘計算出應存入的位置(雜湊演算法)
- 判斷目前位置是否為null,如果是null直接存入
- 如果位置不為null,表示有元素,則調用equals方法比較,如果一樣,則不存,如果不一樣,則存入數組
  - JDK7新元素占老元素位置,指向老元素
  - JDK8新元素挂老元素下面
當數組存滿到16*0.75=12時,就自動擴容,每次擴容原先的兩倍

因為是數組+連結清單的組成方式,是以哈希表是一種對于增删改查資料性能都較好的結構

2.JDK1.8版本開始HashSet原了解析:數組,連結清單,紅黑樹(結合雜湊演算法)

當挂在元素下面的資料過多時,查詢性能降低,從JDK8開始後,當連結清單長度超過8時,自動轉換為紅黑樹

1.3HashSet元素去重複的底層原理

Set集合去重複規則:先判斷哈希值,再判斷equals

如果希望Set集合認為兩個内容一樣的對象是重複的,必須重寫對象的HashCode()和equals()方法:

重寫HashCode方法:
- 因為new兩個内容一樣的對象,這兩個對象位址不同,那得到的哈希值大機率不同,最後就會向HashSet存内容一樣的對象
- 為了避免這種情況我們就要重寫HashCode使内容一樣的對象哈希值一樣
重寫equals方法:
- 因為Object類的equals方法是比較位址是否相同
- 我們的需求是比較對象内容是否相同,是以重寫equals方法

public class SetDemo3 {
    public static void main(String[] args) {
        Set<Student> sets = new HashSet<>();
        Student s1 = new Student("無恙",15);
        Student s2 = new Student("無恙",15);
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        sets.add(s1);
        sets.add(s2);
        System.out.println(sets);
    }
}

public class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

關于重寫後的hashCode方法:

不用管Objects.hash(name, age)内部是怎麼實作的,隻需要知道,兩個内容相同的對象給hash方法傳入的參數一定是一模一樣的,那麼無所謂hash方法内部怎麼實作,反正最後結果一定一樣

1.4LinkedHashSet

存儲和取出的元素順序一緻的原理:底層資料結構依然是哈希表,隻是每個元素又額外多了一個雙連結清單機制記錄存儲的順序

1.5TreeSet

解釋一下可排序:

按照元素的大小預設升序(由小到大)排序
TreeSet集合底層是基于紅黑樹的資料結構實作排序的,增删改查性能都較好
TreeSet集合是一定要排序的,可以将元素按照指定的規則進行排序

TreeSet集合預設的規則:

對于數值類型:Integer,Double,官方預設按照大小進行升序排序

對于字元串類型:預設按照首字元的編号升序排序("a"是97,"A"是65,中文字元好像都是好幾萬)

Set<String> sets1 = new TreeSet<>();
sets1.add("angela");
sets1.add("情話");
sets1.add("Java");
System.out.println(sets1);//輸出[Java, angela, 情話]

對于自定義類型如Student對象,TreeSet無法直接排序(運作會報ClassCastException異常)
- 想要使用TreeSet存儲自定義類型,需要制定排序規則
- 為什麼1.基本資料類型的包裝類如Integer,Double2.引用類型String有預設排序方法呢
  - 因為這些類已經繼承了Comparable接口并重寫了排序方法(後面學到的Collections類的public static void sort(List list)方法等等其他有關排序的方法也是同理)

TreeSet集合存儲對象時有2種方式可以自定義比較規則:

讓自定義的類(如學生類)實作Comparable接口并重寫裡面的compareTo方法來定制比較規則
TreeSet集合有參構造器可以設定Comparator接口對應的比較器對象,來定制比較規則(可以這樣了解:因為TreeSet集合在加入元素時必須要排序,是以有參構造器支援比較器)
如果TreeSet集合存儲的對象有實作比較規則,集合也自帶比較器,根據就近原則預設使用集合自帶的比較器排序

public class SetDemo5 {
    public static void main(String[] args) {
        // 方式二：集合自帶比較器對象進行規則定制
//        Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
//            @Override
//            public int compare(Apple o1, Apple o2) {
//                return o2.getWeight() - o1.getWeight() >= 0 ? 1 : -1;//保留重量重複的元素(降序排序)
//            }
//        });
        
        //方式二的Lambda表達式寫法
        Set<Apple> apples = new TreeSet<>((o1, o2) -> o2.getWeight() - o1.getWeight() >= 0 ? 1 : -1);
        apples.add(new Apple("紅富士", 500));
        apples.add(new Apple("綠蘋果", 400));
        apples.add(new Apple("黃蘋果", 500));
        System.out.println(apples);
    }
}

public class Apple implements Comparable<Apple>{
    private String name;
    private int weight;
    public Apple(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getWeight() {
        return weight;
    }
    public void setWeight(int weight) {
        this.weight = weight;
    }
    @Override
    public String toString() {
        return "Apple{" +
                "name='" + name + '\'' +
                ", weight=" + weight +
                '}';
    }
    //方式一：類自定義比較規則
    @Override
    public int compareTo(Apple o) {
//        return this.weight - o.weight ; // 去重重量重複的元素
         return this.weight - o.weight >= 0 ? 1 : -1;//保留重量重複的元素(升序排序)
    }
}

1.6Collection體系使用場景

如果希望元素可以重複,又有索引,索引查詢要快
- 用ArrayList集合,基于數組的
如果希望元素可以重複,又有索引,增删首尾操作快
- 用LinkedList集合,基于連結清單的
如果希望增删改查都快,但是元素不重複,無序,無索引
- 用HashSet集合,基于哈希表的
如果希望增删改查都快,但是元素不重複,有序,無索引
- 用LinkedHashSet集合,基于哈希表和雙連結清單
如果要對對象進行排序
- 用TreeSet集合,基于紅黑樹
- 後續也可以用List集合實作排序

2.可變參數

可變參數概述:

可變參數用在形參中可以接收多個資料
可變參數的格式:資料類型…參數名稱
可變參數在方法内部本質上就是一個數組

可變參數的作用:

傳輸參數非常靈活,友善.可以不傳參數,可以傳一個或多個參數,也可以傳一個數組

可變參數的注意事項:

一個形參清單中可變參數隻能有一個
可變參數必須放在形參清單的最後面

public class MethodDemo {
    public static void main(String[] args) {
        sum(); // 1、不傳參數
        sum(10); // 2、可以傳輸一個參數
        sum(10, 20, 30); // 3、可以傳輸多個參數
        sum(new int[]{10, 20, 30, 40, 50}); // 4、可以傳輸一個數組
    }
    public static void sum(int...nums){
        // 注意：可變參數在方法内部其實就是一個數組
        System.out.println("元素個數：" + nums.length);
        System.out.println("元素内容：" + Arrays.toString(nums));
    }
}

3.Collections工具類

在util包下,是用來操作集合的工具類:

方法名稱	說明
public static boolean addAll(Collection<? super T> c, T…elements)	給集合對象批量添加元素
public static void shuffle(list<?> list)	打亂List集合元素的順序

1.關于addAll(Collection<? super T> c, T…elements):

第一個參數Collection<? super T> c中的<? super T>表示T的類型是?本身或其孩子比如我給第一個參數傳List,那麼T就可以是Animal或Cat或Dog等等等等
第二個是可變參數,其參數類型是T,是以可變參數的類型就可以是Animal或Cat或Dog等等等等
最後結果是List類型的變量指向的集合對象中可以存放Dog對象
- 但是1.List類型的變量存儲的并不是指向Dog對象的位址(存儲的是List實作類的執行個體對象的位址)
- 2.即使List類型的變量存儲的是指向Dog對象的位址,但是Dog類并沒有繼承List
- 是以嚴格意義上來說這并不是多态隻是呢,我個人認為這個想法來自于多态的理念
  - 回顧一下什麼是多态:Animal a = new Dog();
  - 1.Animal類型的變量存儲的是指向Dog對象的位址
  - 2.Dog類必須繼承Animal類

2.關于shuffle:

看方法源碼會發現底層原理就是周遊數組,每次周遊随機出來一個索引,将此時周遊到的某一進制素與随機出來的索引位置的元素交換位置
為什麼不能對Set集合使用隻能對List集合使用呢,因為List集合底層是數組,而Set集合底層是根據一些算法得到将元素存放到數組的特定位置(後面還有兩個排序的API,同理)

public class CollectionsDemo01 {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names, "gg");
        Collections.addAll(names, new String[] {"楚留香","胡鐵花"});
        System.out.println(names);//[gg, 楚留香, 胡鐵花]
        Collections.shuffle(names);
        System.out.println(names);//[楚留香, gg, 胡鐵花](每次運作程式可能結果都不一樣)
    }
}

Collections相關排序API隻能适用于對List集合的排序:

排序方式一(不可以直接對自定義類型的List集合排序,否則編譯階段報錯,除非自定義類型實作了比較規則Comparable接口):

方法名稱	說明
public static void sort(List list)	将集合中元素按照預設規則排序

排序方式二:

方法名稱	說明
public static void sort(List list, Comparator<? super T> c)	将集合中元素按照指定規則排序

public class CollectionsDemo02 {
    public static void main(String[] args) {
        List<Apple> apples = new ArrayList<>(); // 可以重複！
        apples.add(new Apple("紅富士", 500));
        apples.add(new Apple("綠蘋果", 400));
        apples.add(new Apple("黃蘋果", 500));
         //方式二：sort方法自帶比較器對象
//        Collections.sort(apples, new Comparator<Apple>() {
//            @Override
//            public int compare(Apple o1, Apple o2) {
//                return Double.compare(o2.getWeight() , o1.getWeight());
//            }
//        });

        //方式二的Lambda表達式寫法
        //注意:定制排序規則時不用像TreeSet那樣強制保留大小相同的元素,因為List集存儲相同大小的元素時會自動保留
        Collections.sort(apples, (o1, o2) -> o2.getWeight() - o1.getWeight());
        System.out.println(apples);
    }
}

public class Apple implements Comparable<Apple>{
    private String name;
    private int weight;
    public Apple(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }
    public int getWeight() {
        return weight;
    }
    @Override
    public String toString() {
        return "Apple{" +
                "name='" + name + '\'' +
                ", weight=" + weight +
                '}';
    }
    //方式一：類自定義比較規則
    @Override
    public int compareTo(Apple o) {
        // 按照重量進行比較的
        return this.weight - o.weight ;//TreeSet:return this.weight - o.weight >= 0 ? 1 : -1;
        //這裡不用像TreeSet那樣強制保留大小相同的元素,因為List集存儲相同大小的元素時會自動保留
    }
}

注意事項:

大體和制定Treeset比較規則一樣,差別是:
- TreeSet比較到大小相同元素時會扔掉一個,想保留的話需要用return this.weight - o.weight >= 0 ? 1 : -1;
- List比較到大小相同元素時會自動保留
如果List集合存儲的對象有實作比較規則,調用Collections的sort方法時也指定了排序規則,根據就近原則預設使用調sort方法時指定的排序規則
List和TreeSet排序差別:
- TreeSet是在加入元素時就進行排序了,而List是需要調用Collections的sort方法進行排序
- 如果不保留大小相同的元素,就用TreeSet
- 如果保留大小相同的元素,兩者都可以用

4.Map集合

4.1Map集合概述

Map集合是一種雙列集合,每個元素包含兩個資料
Map集合的每個元素的格式:key=value(鍵值對元素),故Map集合也被稱為"鍵值對集合"
- Map集合的鍵無序,不重複(後面重複的鍵對應的元素會覆寫前面重複的整個元素)
- Map集合的值不做要求,可以重複
- Map集合的鍵值對都可以為null
```
public class MapDemo1 {
    public static void main(String[] args) {
        Map<String, Integer> maps = new LinkedHashMap<>();
        maps.put(null, null);
        System.out.println(maps);//輸出{null=null}
    }
}
           
```
Collection集合和Map集合格式:
- Collection集合的格式:[元素1,元素2,元素3,…]
- Map集合的格式:{key1=value,key2=value,key3=value,…}

4.2Map集合體系

Map集合體系(元素按照是無序,鍵不重複,無索引,值不做要求)
- HashMap(元素按照是無序,鍵不重複,無索引,值不做要求,與Map體系一緻)
  - LinkedHashMap(元素按照鍵有序,鍵不重複,無索引,值不做要求)
- HashTable(不關心,隻關心其子類Properties)
  - Properties
- AbstractMap(不關心,隻關心其實作類TreeMap)
  - TreeMap(元素按照鍵排序,鍵不重複,無索引,值不做要求)

4.3Map集合常用API

方法名稱	說明
V put(K key, V value)	添加元素
V remove(K key, V value)	根據鍵删除鍵值對元素,傳回删除的鍵值對的值
void clear()	移除所有的鍵值對元素
boolean containsKey(Object key)	判斷集合是否包含指定的鍵
boolean containsValue(Object value)	判斷集合是否包含指定的值
boolean isEmpty()	判斷集合是否為空
int size()	集合的長度,也就是集合中鍵值對的個數
Set keySet()	擷取全部建的集合
Collection values()	擷取全部值的集合
V get(Object key)	根據鍵擷取對應值
void putAll(Map<? extends K, ? extends V> m);	合并其他Map集合

關于Set keySet():

Map的鍵是無序不重複的,和Set一樣,是以可以用Set集合接Map的鍵
這個方法内部實際上就是new了一個HashSet來存放集合經過一些操作後傳回該HashSet集合對象
因為HashMap在存放資料時鍵的底層和HashSet實作原理一樣,是以keySet()方法得到的鍵的Set集合中元素順序和HashMap中鍵順序一緻

關于Collection values():

為什麼這裡用Collection接Map的值呢:因為值可能重複,如果還用Set的話會丢失資料
values方法内部可能new了List集合的子類,然後将HashMap中元素的值依次存放到數組中,是以values方法得到的值的Collection集合中元素順序和HashMap中值順序一緻

public class MapDemo {
    public static void main(String[] args) {
        // 1.添加元素: 無序，不重複，無索引。
        Map<String , Integer> maps = new HashMap<>();
        maps.put("iphoneX",10);
        maps.put("娃娃",20);
        maps.put("iphoneX",100);//Map集合後面重複的鍵對應的元素會覆寫前面重複的整個元素！
        maps.put("huawei",200);
        maps.put("生活用品",50);
        System.out.println(maps);//{huawei=200, 生活用品=50, iphoneX=100, 娃娃=20}
        // 2.清空集合
//        maps.clear();
        // 3.判斷集合是否為空
        System.out.println(maps.isEmpty());//false
        // 4.根據鍵擷取對應值
        Integer key = maps.get("huawei");
        System.out.println(key);//200
        System.out.println(maps.get("生活用品"));//50
        System.out.println(maps.get("生活用品2"));//null
        // 5.根據鍵删除整個元素
        System.out.println(maps.remove("iphoneX"));//100
        System.out.println(maps);//{huawei=200, 生活用品=50, 娃娃=20}
        // 6.判斷是否包含某個鍵
        System.out.println(maps.containsKey("娃娃"));// true
        System.out.println(maps.containsKey("娃娃2"));// false
        // 7.判斷是否包含某個值
        System.out.println(maps.containsValue(200));//true
        // 8.擷取全部鍵的集合
        Set<String> keys = maps.keySet();
        System.out.println(keys);//[huawei, 生活用品, 娃娃],注意順序:和HashMap中元素順序一緻
        // 9.擷取全部值的集合
        Collection<Integer> values = maps.values();
        System.out.println(values);//[200, 50, 20],注意順序:和HashMap中元素順序一緻
        // 10.集合的大小
        System.out.println(maps.size());//3
        // 11.合并其他Map集合
        Map<String , Integer> map1 = new HashMap<>();
        map1.put("java1", 1);
        map1.put("java2", 100);
        Map<String , Integer> map2 = new HashMap<>();
        map2.put("java2", 1);
        map2.put("java3", 100);
        map1.putAll(map2); // 把集合map2的元素拷貝一份到map1中去
        System.out.println(map1);//{java3=100, java2=1, java1=1}
        System.out.println(map2);//{java3=100, java2=1}
    }
}

4.4Map集合的周遊方式

4.4.1周遊方式一:鍵找值

先擷取Map集合的全部建的Set集合
周遊建的Set集合,然後通過鍵提取對應值

鍵找值涉及到的API:

方法名稱	說明
Set keySet()	擷取全部建的集合
V get(Object key)	根據鍵擷取對應值

public class MapDemo01 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        maps.put("娃娃",30);
        maps.put("iphoneX",100);
        System.out.println(maps);
        Set<String> keys = maps.keySet();
        for (String key : keys) {
            int value = maps.get(key);//自動拆箱
            System.out.println(key + "===>" + value);
        }
    }
}

4.4.2周遊方式二:鍵值對

先把Map集合轉換成Set集合,Set集合中每個元素都是鍵值對實體類型了(HashMap是一個鍵值對的集合,裡面的鍵和值作為整體沒有所謂的類型,是以我們不能通過簡單的循環來周遊HashMap)
周遊Set集合,然後提取鍵以及提取值

鍵值對涉及到的API:

方法名稱	說明
Set<Map.Entry<K, V>> entrySet()	擷取所有鍵值對對象的集合
K getKey()	擷取某一個鍵值對元素的鍵
V get(Object key)	根據鍵擷取對應值

public class MapDemo02 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        maps.put("娃娃",30);
        maps.put("iphoneX",100);
        System.out.println(maps);
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();//這一步的底層原理以後再研究
        for(Map.Entry<String, Integer> entry : entries){
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key + "====>" + value);
        }
    }
}

4.4.2周遊方式三:Lambda表達式

得益于JDK 8開始的新技術Lambda表達式,提供了一種更簡單,更直接的周遊集合的方式

Map結合Lambda周遊的API

方法名稱	說明
default void forEach(BiConsumer<? super K, ? super V> action)	結合Lambda周遊Map集合

public class MapDemo03 {
    public static void main(String[] args) {
        Map<String , Integer> maps = new HashMap<>();
        maps.put("娃娃",30);
        maps.put("iphoneX",100);
        System.out.println(maps);
        //方式三
        maps.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String key, Integer value) {
                System.out.println(key + "--->" + value);
            }
        });
        //方式三的Lambda表達式簡化
        maps.forEach((k, v) -> {
                System.out.println(k + "--->" + v);
        });
    }
}

點進去forEach看源碼會發現這其實就是一個換殼簡化,實際上還是用了方式二的這種方法

default void forEach(BiConsumer<? super K, ? super V> action) {
    Objects.requireNonNull(action);
    for (Map.Entry<K, V> entry : entrySet()) {
        K k;
        V v;
        try {
            k = entry.getKey();
            v = entry.getValue();
        } catch(IllegalStateException ise) {
            throw new ConcurrentModificationException(ise);
        }
        action.accept(k, v);
    }
}

4.5集合案例

某個班80名學生,現在需要組成秋遊活動,班長提供了四個景點依次是(A,B,C,D),每個學生隻能選擇一個景點,請統計最終哪個景點想去的人數最多

public class MapTest1 {
    public static void main(String[] args) {
         // 1、把80個學生選擇的資料拿進來。
        String[] selects = {"A" , "B", "C", "D"};
        StringBuilder sb = new StringBuilder();
        Random r = new Random();
        for (int i = 0; i < 80; i++) {
            sb.append(selects[r.nextInt(selects.length)]);
        }
        System.out.println(sb);

        // 2、定義一個Map集合記錄最終統計的結果： A=30 B=20 C=20 D=10  鍵是景點 值是選擇的數量
        Map<Character, Integer> infos = new HashMap<>(); //

        // 3、周遊80個學生選擇的資料
        for (int i = 0; i < sb.length(); i++) {
            // 4、提取目前選擇景點字元
            char ch = sb.charAt(i);
            // 5、判斷Map集合中是否存在這個鍵
            if(infos.containsKey(ch)){
                 // 讓其值 + 1
                infos.put(ch , infos.get(ch) + 1);
            }else {
                // 說明此景點是第一次被選
                infos.put(ch , 1);
            }
        }

        // 4、輸出集合
        System.out.println(infos);

    }
}

4.6HashMap集合

HashMap是Map裡面的一個實作類,特點都是由鍵決定的:無序,不重複,無索引
- 依賴HashCode方法和equals方法保證鍵的唯一
- 如果鍵要存儲的是自定義對象,需要重寫hashCoe和equals方法
沒有額外需要學習的方法,直接使用Map裡面的方法就可以了
HashMap跟HashSet底層原理一模一樣,都是哈希表結構,增删改查性能都比較好,隻是HashMap的每個元素包含兩個值而已
實際上,Set系列的集合的底層就是Map實作的,隻是Set集合中的元素隻要鍵資料,不要值資料而已,是以Map底層直接去看1.2和1.3就可以了,學到這裡了順便糾正一下,1.2和1.3講解的底層嚴格意義上來講不應該算是Set的底層而應該算是Map的底層,然後Set進行調用,說白了Set的底層實作是依據Map例如:
```
public HashSet() {
    map = new HashMap<>();
}
           
```

4.7LinkedHashMap集合

LinkedHashSet底層就是依據LinkedHashMap做的
有序,不重複,無索引(這裡的有序指的是保證存儲和取出的元素順序一緻)
原理:底層資料結構依然是哈希表,隻是每個鍵值對元素又額外多了一個雙連結清單的機制記錄存儲的順序

4.8TreeMap集合

TreeSet底層就是依據TreeMap做的
不重複,無索引,可排序
- 排序是按照鍵資料的大小預設升序(隻能對鍵排序,且如果是自定義的引用類型那麼必須自定義排序規則)
- 自定義排序規則有2種:
  - 類實作Comparable接口,重寫比較規則
  - 集合自定義Comparator比較器對象,重寫比較規則

4.9集合嵌套案例

某個班80名學生,現在需要組成秋遊活動,班長提供了四個景點依次是(A,B,C,D),每個學生可以選擇景點,請統計最終哪個景點想去的人數最多

public class MapTest4 {
    public static void main(String[] args) {
        // 1、要求程式記錄每個學生選擇的情況,使用一個Map集合存儲
        Map<String, List<String>> data = new HashMap<>();

        // 2、把學生選擇的資料存入進去。
        List<String> selects = new ArrayList<>();
        Collections.addAll(selects, "A", "C");
        data.put("羅勇", selects);
        List<String> selects1 = new ArrayList<>();
        Collections.addAll(selects1, "B", "C" , "D");
        data.put("胡濤", selects1);
        List<String> selects2 = new ArrayList<>();
        Collections.addAll(selects2 , "A",  "B", "C" , "D");
        data.put("劉軍", selects2);
        System.out.println(data);//{劉軍=[A, B, C, D], 胡濤=[B, C, D], 羅勇=[A, C]}

        // 3、統計每個景點選擇的人數。
        Map<String, Integer> infos = new HashMap<>(); // {}

        // 4、提取所有人選擇的景點的資訊。
        Collection<List<String>> values = data.values();
        System.out.println(values);//[[A, B, C, D], [B, C, D], [A, C]]

        for (List<String> value : values) {
            for (String s : value) {
                // 有沒有包含這個景點
                if(infos.containsKey(s)){
                    infos.put(s, infos.get(s) + 1);
                }else {
                    infos.put(s , 1);
                }
            }
        }
        System.out.println(infos);//{A=2, B=2, C=3, D=2}
    }
}

20天深度複習JavaSE的詳細筆記(十三)——集合（Set、Collections、Map、集合嵌套）Demo13-集合（Set、Collections、Map、集合嵌套）