集合框架被設計成要滿足以下幾個目標， 該框架必須是高性能的，基本集合（動態陣列，鏈表，樹，哈希表）的實作也必須是高效的，
該框架允許不同型別的集合，以類似的方式作業，具有高度的互操作性，對一個集合的擴展和適應必須是簡單的，為此，整個集合框架就圍繞一組標準介面而設計，你可以直接使用這些介面的標準實作，諸如：
LinkedList, HashSet, 和 TreeSet 等,除此之外你也可以通過這些介面實作自己的集合，

Collection集合

Collection集合的簡單概述

是單例集合的頂層介面，它表示一組物件，這些物件也稱為Collection的元素
JDK不提供此介面的任何直接實作，它提供更具體的子介面（如Set和List）實作
代碼舉例:

public class CollectionDemo01 {
    public static void main(String[] args) {
        //創建Collection集合的物件
        Collection<String> c = new ArrayList<String>();
        //添加元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");

        //輸出集合物件
        System.out.println(c);//重寫了ToString方法
    }
}

Collection集合常用方法

List集合

List集合的基本概述

有序集合(也稱為序列)，用戶可以精確控制串列中每個元素的插入位置，用戶可以通過整數索引訪問元素，并搜索串列中的元素,與Set集合不同，串列通常允許重復的元素，

List集合的特點

1. 有索引(有索引意味著可以通過普通for回圈通過索引來對集合遍歷)
2. 存取有序(集合元素添加的順序和取出的順序一致)
3. 集合中的元素可以重復

List集合特有方法

ArrayList集合&LinkedList集合

ArrayList集合

ArrayList底層是用陣列實作的，可以認為ArrayList是一個可改變大小的陣列，隨著越來越多的元素被添加到ArrayList中，其規模是動態增加的，
集合的創建：
ArrayList<Integer> arrayList = new ArrayList<Integer>();

LinkedList集合

LinkedList底層是通過雙向鏈表實作的，
集合的創建：
LinkedList<Integer> linkedList = new LinkedList<Integer>();

LinkedList集合的特有功能

因為LinkedList集合的底層是雙向鏈表所以具有鏈表結構的一些特定操作

ArrayList集合 VS LinkedList集合

LinkedList和ArrayList的區別主要就是陣列和鏈表的區別，
陣列中查詢比較快，因為可以直接通過陣列索引訪問
鏈表中洗掉和增加比較快，因為可以直接通過節點的變數指定進行元素的增刪，
LinkedList和ArrayList相比，增刪的速度較快，但是查詢的速度較慢

Set集合

Set集合的特點

1. 存取無序(集合元素添加的順序和取出的順序不一致)
2. 沒有索引,只能通過迭代器或增強for回圈遍歷.
3. 不能存盤重復元素()

基本使用

public class SetDemo {
    public static void main(String[] args) {
        //創建集合物件
        Set<String> set = new HashSet<String>();//多型
        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重復元素的集合
        set.add("world");
        //增強for遍歷
        for(String s : set) {
            System.out.println(s);
        }
    }
}

HashSet集合&TreeSet集合

HashSet集合

HashSet集合的特點

1. 底層資料結構是哈希表
2. 對集合的迭代順序不作任何保證，也就是說不保證存盤和取出的元素順序一致
3. 沒有帶索引的方法，所以不能使用普通for回圈遍歷
4. 由于是Set集合，所以是不包含重復元素的集合

HashSet集合的基本使用

public class HashSetDemo01 {
    public static void main(String[] args) {
        //創建集合物件
        HashSet<String> hs = new HashSet<String>();

        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");

        hs.add("world");

        //遍歷
        for(String s : hs) {
            System.out.println(s);
        }
    }
}

LinkedHashSet集合

LinkedHashSet集合特點

1. 哈希表和鏈表實作的Set介面，具有可預測的迭代次序
2. 由鏈表保證元素有序，也就是說元素的存盤和取出順序是一致的
3. 由哈希表保證元素唯一，也就是說沒有重復的元素

基本使用

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //創建集合物件
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();

        //添加元素
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");

        linkedHashSet.add("world");

        //遍歷集合
        for(String s : linkedHashSet) {
            System.out.println(s);
        }
    }
}

TreeSet集合

TreeSet集合的概述和特點

1. 元素有序(不值存取有序)，可以按照一定的規則進行排序，具體排序方式取決于構造方法
   TreeSet()：根據其元素的自然排序進行排序(無參)
   TreeSet(Comparator comparator) ：根據指定的比較器進行排序(帶參)
2. 沒有帶索引的方法，所以不能使用普通for回圈遍歷
3. 3.由于是Set集合，所以不包含重復元素的集合

TreeSet集合基本使用

public class TreeSetDemo01 {
    public static void main(String[] args) {
        //創建集合物件
        TreeSet<Integer> ts = new TreeSet<Integer>();
        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);
        ts.add(30);
        //遍歷集合
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}

自然排序

• 用TreeSet集合存盤自定義物件，無參構造方法使用的是自然排序對元素進行排序的
• 自然排序，就是讓元素所屬的類實作Comparable介面，重寫compareTo(T o)方法
• 重寫方法時，一定要注意排序規則必須按照要求的主要條件和次要條件來寫

 @Override
    public int compareTo(Student s) {
        //按照年齡從小到大排序
       int num = this.age - s.age;
      int num = s.age - this.age;
        //年齡相同時，按照姓名的字母順序排序
       int num2 = num==0?this.name.compareTo(s.name):num;
        return num2;
    }

比較器排序

• 用TreeSet集合存盤自定義物件，帶參構造方法使用的是比較器排序對元素進行排序的
• 比較器排序，就是讓集合構造方法接收Comparator的實作類物件，重寫compare(T o1,T o2)方法
• 重寫方法時，一定要注意排序規則必須按照要求的主要條件和次要條件來寫

 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //this.age - s.age
                //s1,s2
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

Map集合

Map集合概述

Map 是一種鍵-值對（key-value）集合，Map 集合中的每一個元素都包含一個鍵物件和一個值物件，

Map集合特點

1. 鍵值對映射關系
2. 一個鍵對應一個值
3. 鍵不能重復，值可以重復
4. 元素存取無序

Map集合的基本使用

public class MapDemo01 {
    public static void main(String[] args) {
        //創建集合物件
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key, V value) 將指定的值與該映射中的指定鍵相關聯
        map.put("itheima001","林青霞");
        map.put("itheima002","張曼玉");
        map.put("itheima003","王祖賢");
        map.put("itheima003","柳巖");

        //輸出集合物件
        System.out.println(map);
    }
}

Map集合的常用方法

方法說明:

示例:

public class MapDemo02 {
    public static void main(String[] args) {
        //創建集合物件
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key,V value)：添加元素
        map.put("張無忌","趙敏");
        map.put("郭靖","黃蓉");
        map.put("楊過","小龍女");

        //V remove(Object key)：根據鍵洗掉鍵值對元素
//        System.out.println(map.remove("郭靖"));
//        System.out.println(map.remove("郭襄"));

        //void clear()：移除所有的鍵值對元素
//        map.clear();

        //boolean containsKey(Object key)：判斷集合是否包含指定的鍵
//        System.out.println(map.containsKey("郭靖"));
//        System.out.println(map.containsKey("郭襄"));

        //boolean isEmpty()：判斷集合是否為空
//        System.out.println(map.isEmpty());

        //int size()：集合的長度，也就是集合中鍵值對的個數
        System.out.println(map.size());


        //輸出集合物件
        System.out.println(map);
    }
}

Map集合的獲取方法

方法說明:

示例:

public class MapDemo03 {
    public static void main(String[] args) {
        //創建集合物件
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("張無忌", "趙敏");
        map.put("郭靖", "黃蓉");
        map.put("楊過", "小龍女");

        //V get(Object key):根據鍵獲取值
//        System.out.println(map.get("張無忌"));
//        System.out.println(map.get("張三豐"));

        //Set<K> keySet():獲取所有鍵的集合
//        Set<String> keySet = map.keySet();
//        for(String key : keySet) {
//            System.out.println(key);
//        }

        //Collection<V> values():獲取所有值的集合
        Collection<String> values = map.values();
        for(String value : values) {
            System.out.println(value);
        }
    }
}

Map集合的遍歷方式

方式一

• 遍歷思路
  • 我們剛才存盤的元素都是成對出現的，所以我們把Map看成是一個夫妻對的集合
    • 把所有的丈夫給集中起來
    • 遍歷丈夫的集合，獲取到每一個丈夫
    • 根據丈夫去找對應的妻子
• 步驟分析
  • 獲取所有鍵的集合，用keySet()方法實作
  • 遍歷鍵的集合，獲取到每一個鍵，用增強for實作
  • 根據鍵去找值，用get(Object key)方法實作
• 代碼實作

public class MapDemo01 {
    public static void main(String[] args) {
        //創建集合物件
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("張無忌", "趙敏");
        map.put("郭靖", "黃蓉");
        map.put("楊過", "小龍女");

        //獲取所有鍵的集合，用keySet()方法實作
        Set<String> keySet = map.keySet();
        //遍歷鍵的集合，獲取到每一個鍵，用增強for實作
        for (String key : keySet) {
            //根據鍵去找值，用get(Object key)方法實作
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

方式二

• 遍歷思路

  • 我們剛才存盤的元素都是成對出現的，所以我們把Map看成是一個夫妻對的集合
    • 獲取所有結婚證的集合
    • 遍歷結婚證的集合，得到每一個結婚證
    • 根據結婚證獲取丈夫和妻子

• 步驟分析

  • 獲取所有鍵值對物件的集合
    • Set<Map.Entry<K,V>> entrySet()：獲取所有鍵值對物件的集合
  • 遍歷鍵值對物件的集合，得到每一個鍵值對物件
    • 用增強for實作，得到每一個Map.Entry
  • 根據鍵值對物件獲取鍵和值
    • 用getKey()得到鍵
    • 用getValue()得到值

• 代碼實作

public class MapDemo02 {
    public static void main(String[] args) {
        //創建集合物件
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("張無忌", "趙敏");
        map.put("郭靖", "黃蓉");
        map.put("楊過", "小龍女");

        //獲取所有鍵值對物件的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍歷鍵值對物件的集合，得到每一個鍵值對物件
        for (Map.Entry<String, String> me : entrySet) {
            //根據鍵值對物件獲取鍵和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}

Map介面和Collection介面的不同

它們兩個不存在繼承關系，都是屬于java.util包下面的平級關系
Map集合存盤的元素都是成對出現的，Map元素的鍵是唯一的，值是可以重復，把這樣的元素理解為：夫妻對
Collection集合存盤的元素都是單獨出現的，Collection介面下面的Set是元素唯一的， List集合中元素是可以重復的，