Java基礎（六）——集合

一、概述

1、介紹

　　為什么出現集合？
　　答：面向對象語言對事物的體現都是以對象的形式，所以為了方便對多個對象的操作，對對象進行存儲，集合就是存儲對象最常用的一種方式。
　　數組和集合類同是容器，有何不同？
　　答：數組雖然也可以存儲對象，但長度是固定的，集合長度是可變的。數組中可以存儲基本數據類型，集合中只能存儲對象（引用類型，基本類型的包裝類型）。
　　為什么會出現這么多的容器呢？
　　答：因為每一個容器對數據的存儲方式都有不同。這個存儲方式稱之為：數據結構。
　　什么是迭代器呢？
　　答：其實就是集合的取出元素的方式。

2、集合框架

　　簡圖：

　　Collection：

　　Map：

二、Collection<E>(jdk1.2)

　　集合中存儲的都是對象的引用（地址）。

1、常用方法

　　add(Object obj)：添加。
　　addAll(Collection coll)：添加。
　　int size()：獲取有效元素的個數。
　　void clear()：清空集合。
　　boolean isEmpty()：是否是空集合。
　　boolean contains(Object obj)：是否包含某個元素，通過元素的equals方法來判斷是否是同一個對象。
　　boolean containsAll(Collection c)：也是調用元素的equals方法來比較的。兩個集合的元素挨個比較。

　　boolean remove(Object obj) ：刪除，通過元素的equals方法判斷是否是要刪除的那個元素。只會刪除找到的第一個元素。
　　boolean removeAll(Collection coll)：刪除，取當前集合的差集。
　　boolean retainAll(Collection c)：取交集，把交集的結果存在當前集合中，不影響c。
　　boolean equals(Object obj)：集合是否相等。
　　Object[] toArray()：轉成對象數組。
　　hashCode()：獲取集合對象的哈希值。
　　iterator()：返回迭代器對象，用於集合遍歷。

　　代碼示例：基本方法

public class Main {
    public static void main(String[] args) {
        Collection<Object> coll = new ArrayList<>();

        coll.add("AA");
        coll.add("BB");
        coll.add(123); // 自動裝箱
        coll.add(new Date());

        System.out.println(coll.size());  // 4

        Collection<Object> coll1 = new ArrayList<>();
        coll1.add(456);
        coll1.add("CC");
        coll1.add(123);

        coll.addAll(coll1);
        System.out.println(coll);

        coll.clear(); // 清空集合元素
        
        System.out.println(coll.isEmpty()); // true
    }
}

　　代碼示例：初始化類

// 預先定義的實體類
public class Person {

    private String name;
    private int age;

    // 無參構造器
    // 有參構造器
    // getter & setter
    // toString()

    @Override
    public boolean equals(Object o) {
        System.out.println("Person equals()....");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

// 初始化的集合.下面的代碼示例,集合都是這個.
public Collection<Object> init() {
    Collection<Object> coll = new ArrayList<>();
    
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry", 20));
    coll.add("Tom");
    coll.add(false);

    return coll;
}

public void method1() {
    System.out.println(coll.hashCode());

    // 判斷當前集合中是否包含obj
    // 想要按 Person 對象的屬性來比較，需要復寫 equals(Object o)
    // false --> true
    System.out.println(coll.contains(new Person("Jerry", 20)));

    // 當且僅當形參中的所有元素都存在於當前集合中.true
    // true
    System.out.println(coll.containsAll(Arrays.asList(123, 456)));

    coll.remove(1234);
    coll.remove(new Person("Jerry", 20));
    // 差集：A - B
    coll.removeAll(Arrays.asList(123, 4567));

    System.out.println(coll);

    // 兩個集合完全相同,包括順序相同(這個又具體子類決定)
    // System.out.println(coll.equals(coll1));

    // 交集
    coll.retainAll(Arrays.asList(123, 666));
    System.out.println(coll);
}

// 結果
-1200490100
Person equals()....
Person equals()....
Person equals()....
true
true
Person equals()....
Person equals()....
Person equals()....
[456, Tom, false]
[]

　　結果分析：
　　①判定一個集合中是否包含某個對象，contains(Object o)方法，會調用equals(Object o)去比較，所以需要復寫equals(Object o)方法。
　　②對象Person是第3個被加入到集合中的，比較的時候需要一個一個比較，所以equals()方法被調用了3次。
　　③remove(Object o)時同樣equals()方法被調用了3次。

　　代碼示例：集合 <--> 數組

public void method2() {
    // 集合 --> 數組
    final Object[] objects = coll.toArray();
    final Object[] array = coll.toArray(new Object[0]);

    // 數組 --> 集合
    final List<String> strings = Arrays.asList("A", "B", "C");
    final List<Integer> integers = Arrays.asList(123, 456);
}

2、Iterator<E>（迭代器）

　　GOF給迭代器模式的定義為：提供一種方法訪問一個容器（container）對象中各個元素，而又不需暴露該對象的內部細節。迭代器模式，就是為容器而生。類似於"公交車上的售票員"、"火車上的乘務員"、"空姐"。
　　一種集合的取出元素的方式。定義在集合的內部，用於直接訪問集合內 部的元素，是一個內部類。集合對象每次調用iterator()方法都得到一個全新的迭代器對象，默認游標都在集合的第一個元素之前。Iterator主要用於遍歷Collection，不包括map。
　　用foreach遍歷Collection，底層還是使用的迭代器。迭代器原理：

　　JDK8源碼：

　　代碼示例：迭代器的使用

// 注意：這里是迭代器里的remove，不是集合里面的。
public void method3() {
    Iterator<Object> iterator = coll.iterator();
    while (iterator.hasNext()) {
        // next():①指針下移 ②將下移以后集合位置上的元素返回
        System.out.println(iterator.next());
    }

    // 返回一個全新的迭代器
    iterator = coll.iterator();
    while (iterator.hasNext()) {
        // iterator.remove(); 報錯IllegalStateException
        final Object next = iterator.next();

        if ("Tom".equals(next)) {
            iterator.remove();
            // iterator.remove(); 報錯IllegalStateException
        }
    }
}

3、List<E>、Queue<E>、Set<E>（重點）

　　List<E>元素是有序的，可重復，因為該集合體系有索引。實現類：
　　ArrayList：底層使用的數組數據結構。特點：查詢速度很快，但是增刪稍慢（會移動后面的元素）。初始長度10，50%延長。線程不同步的。jdk1.2
　　LinkedList：底層使用的鏈表數據結構。特點：增刪速度很快，查詢稍慢。線程不同步的。
　　Vector：底層使用的數組數據結構。初始長度10，100%延長。線程同步的。后被ArrayList替代了。jdk1.0

　　Queue<E>有序的，可重復。實現類：
　　Deque<E>（接口）：
　　LinkedList：底層使用的鏈表數據結構。特點：增刪速度很快，查詢稍慢。線程不同步的。

　　Set<E>元素是無序的，不重復。沒有索引。實現類：
　　HashSet：底層使用的HashMap（數組+鏈表）數據結構。無序的，不可重復，線程不同步。可以存儲null值。
　　TreeSet：底層使用的TreeMap（排序二叉樹，紅黑樹）數據結構。可以對set集合中的元素按指定屬性進行排序。有序的。查詢速度比List快。

三、List<E>

1、ArrayList<E>

　　代碼示例：迭代器的使用

// 其他常用方法不演示
public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");

        final Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next());
        }
    }
}

// 結果
// A B C D

2、Vector<E>

　　枚舉就是Vector特有的取出方式，和迭代器很像，其實是一樣的，由於名稱過長，后被迭代器取代了。

public static void main(String[] args) {
    Vector<String> vector = new Vector<>();

    vector.add("A");
    vector.add("B");

    // 返回此向量的組件的枚舉.
    final Enumeration<String> elements = vector.elements();

    while (elements.hasMoreElements()) {
        System.out.println(elements.nextElement());
    }
}

// 結果
// A B

3、Stack<E>（棧）

// 先進后出
public class Main {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();

        // 壓棧
        stack.push("A");
        stack.push("B");
        stack.push("C");

        while (!stack.empty()) {
            // 從棧頂彈出一個.會刪除元素
            System.out.println(stack.pop());
        }

        // 從棧頂彈出一個.不會刪除元素
        // stack.peek();
    }
}

// 結果
C B A

四、Queue<E>

1、Queue<E>（隊列）

// 先進先出
public class Main {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        // 添加.入隊
        queue.offer(1);
        queue.offer(10);
        queue.offer(5);
        queue.offer(9);
        System.out.println(queue);

        // 出隊
        final Integer poll = queue.poll();
        System.out.println(poll);
        System.out.println(queue);

        // 獲取.隊頭
        final Integer peek = queue.peek();
        System.out.println(peek);
        System.out.println(queue);
    }
}

// 結果
[1, 10, 5, 9]
1
[10, 5, 9]
10
[10, 5, 9]

2、Deque<E>（雙端隊列）

3、LinkedList<E>（雙向鏈表）

　　對於頻繁的插入或刪除元素的操作，建議使用LinkedList類，效率較高。

　　特有方法
　　addFirst()：在第一個位置添加元素。
　　addLast()
　　getFirst()：獲取第一個元素，但不刪除元素。若沒有，出現異常。
　　getLast()
　　removeFirst()：獲取元素，但是刪除元素。若沒有，出現異常。
　　removeLast()

　　在jdk1.6以后出現了替代方法。
　　offerFirst()：在第一個位置添加元素。
　　offerLast()
　　peekFirst()：獲取元素，但不刪除元素。若沒有，返回null。
　　peekLast()
　　pollFirst()：獲取元素，但是刪除元素。若沒有，返回null。
　　pollLast()

五、Set<E>

1、介紹

　　Set<E>元素是不重復。沒有索引。實現類：
　　HashSet：底層使用的HashMap（數組+鏈表）數據結構。無序的，不可重復，線程不安全。可以存儲null值。
　　LinkedHashSet：底層使用的 LinkedHashMap。無序的，不可重復。
　　TreeSet：底層使用的TreeMap（排序二叉樹，紅黑樹）數據結構。可以對set集合中的元素按指定屬性進行排序。有序的。查詢速度比List快。

　　以HashSet為例理解無序、不重復：
　　無序的：不等於隨機性（並不是說打印的順序沒有按照添加的順序），是指的存儲的數據在底層數組中並非按照數組索引的順序依次添加，而是根據數據的哈希值確定的索引位置。
　　不重復：調用對象equals()方法保證相同元素只添加一次。
　　要求：向Set（主要指：HashSet、LinkedHashSet）中添加的數據，其所在的類一定要重寫hashCode()和equals()。重寫的hashCode()和equals()盡可能保持一致性：相等的對象必須具有相等的散列碼。

　　重寫 hashCode() 方法的基本原則：
　　（1）程序運行時，同一個對象多次調用 hashCode() 方法應該返回相同的值。
　　（2）當兩個對象的 equals() 方法比較返回 true 時，這兩個對象的 hashCode() 方法的返回值也應相等。
　　（3）對象中用作 equals() 方法比較的 Field，都應該用來計算 hashCode 值。

　　重寫 equals() 方法的基本原則：
　　當一個類有自己特有的"邏輯相等"概念，需要重寫equals()的時候，總是要重寫hashCode()，根據一個類的equals方法（改寫后），兩個截然不同的實例有可能在邏輯上是相等的，但是，根據Object.hashCode()方法，它們僅僅是兩個對象。因此，違反了"相等的對象必須具有相等的散列碼"。
　　結論：復寫equals方法的時候一般都需要同時復寫hashCode方法。通常參與計算hashCode的對象的屬性也應該參與到equals()中進行計算。

2、HashSet<E>

　　HashSet 按 Hash 算法來存儲集合中的元素，因此具有很好的存取、查找和刪除性能。
　　底層數據結構：看JDK8的源碼，HashSet底層是一個HashMap。而HashMap底層是數組+鏈表（7），數組+鏈表+紅黑樹（8）。
　　元素添加過程：由於HashSet底層就是HashMap，所以它的原理只需要了解HashMap即可。

// API使用
public class Main {
    public static void main(String[] args) {
        Set<String> set1 = new HashSet<>();
        Set<String> set2 = new HashSet<>();

        set1.add("a");
        set1.add("b");
        set1.add("c");

        set2.add("c");
        set2.add("d");
        set2.add("e");

        // 取交集
        set1.retainAll(set2);
        System.out.println(set1); // [c]
        // 取並集
        // set1.addAll(set2);
        // System.out.println(set1); // [a, b, c, d, e]
        // 取差集
        // set1.removeAll(set2);
        // System.out.println(set1); // [a, b]
    }
}

3、LinkedHashSet<E>

　　作為HashSet的子類，LinkedHashSet 根據元素的 hashCode 值來決定元素的存儲位置（依然是無序的）， 但它同時使用雙向鏈表維護元素的添加次序，這使得元素看起來是以插入順序保存的。也可以按照添加的順序遍歷。
　　對於頻繁的遍歷操作，LinkedHashSet效率高於HashSet。LinkedHashSet插入性能略低於 HashSet。
　　代碼示例：

public class Main {
    public static void main(String[] args) {
        Set set = new LinkedHashSet();
        set.add("AA");
        set.add(456);
        set.add(456);

        set.add(new User("劉德華", 60));
        
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

// 結果:按照添加的順序遍歷.
AA
456
User{name='劉德華', age=60}

// 若Set set = new HashSet();則遍歷不按照添加的順序

　　底層結構：

4、TreeSet<E>

　　底層是排序二叉樹，所以①必須是相同類型的對象。②必須可排序。自然排序（實現Comparable接口）和定制排序（Comparator）。
　　自然排序中，判斷兩個對象是否相同的標准為：compareTo()返回0，不是equals()。
　　定制排序中，判斷兩個對象是否相同的標准為：compare()返回0。不是equals()。
　　若compareTo始終返回0，則add始終只有一個元素。因為后面的都認為與前面的相同，因此沒有加入進來。判斷兩個對象是否相等的標准是compareTo返回值相同。
　　底層數據結構：看JDK8的源碼，TreeSet底層是一個TreeMap。采用紅黑樹的存儲結構。有序的。查詢速度比List快。
　　元素添加過程：
　　代碼示例：讓User具有可比性，自然排序：Comparable

public class User implements Comparable<User> {
    private String name;
    private int age;

    // 無參構造器
    // 有參構造器
    // getter & setter
    // toString()
    // 可以不復寫equals、hashCode
    
    @Override
    public int compareTo(User user) {
        System.out.println(this.name + "-------------" + user.getName());

        if (this.age > user.age) {
            return 1;
        }
        if (this.age < user.age) {
            return -1;
        }
        return 0;
    }
}

// 測試類
public static void main(String[] args) {
    TreeSet<User> treeSet = new TreeSet<>();

    treeSet.add(new User("java1", 30));
    treeSet.add(new User("java2", 20));
    treeSet.add(new User("java3", 31));
    treeSet.add(new User("java4", 60));

    final Iterator<User> iterator = treeSet.iterator();
    while (iterator.hasNext()) {
        final User user = iterator.next();
        System.out.println(user.getName() + "---------" + user.getAge());
    }
}

// 結果
java1-------------java1 // 第一次
java2-------------java1 // 2和1比,2在左邊
java3-------------java1 // 3和1比,3在右邊
java4-------------java1 // 4和1比,4在右邊
java4-------------java3 // 4和3比,4在右邊
java2---------20
java1---------30
java3---------31
java4---------60

　　結果分析：不難理解打印結果的比較次數。

　　代碼示例：指定比較器，定制排序：Comparator

// 比較器
public static void main(String[] args) {
    final Comparator<User> comparator = new Comparator<User>() {
        // 按照年齡從小到大排列
        @Override
        public int compare(User o1, User o2) {
            return Integer.compare(o1.getAge(), o2.getAge());
        }
    };

    TreeSet<User> treeSet = new TreeSet<>(comparator);

    treeSet.add(new User("java1", 30));
    treeSet.add(new User("java2", 20));
    treeSet.add(new User("java3", 31));
    treeSet.add(new User("java4", 60));
    treeSet.add(new User("java5", 60));

    final Iterator<User> iterator = treeSet.iterator();
    while (iterator.hasNext()) {
        final User user = iterator.next();
        System.out.println(user.getName() + "---------" + user.getAge());
    }
}

// 結果
java2---------20
java1---------30
java3---------31
java4---------60

六、Map<K,V>

1、介紹（重點）

　　雙列數據，存儲key-value對的數據。用作鍵的對象必須實現hashCode方法和equals方法。實現類：
　　HashMap：底層使用的（數組+鏈表7+紅黑樹8）數據結構。特點：可以存入null鍵null值。線程不同步，效率高。jdk1.2
　　Hashtable：底層使用的（數組+鏈表）數據結構。特點：不可以存入null鍵null值。線程同步，效率低。jdk1.0
　　TreeMap：底層使用的（排序二叉樹，紅黑樹）數據結構。實現了SortedMap有序序列接口，特點：可以用於給map集合中的鍵按指定屬性進行排序。線程不同步。
　　WeakHashMap：底層使用的（數組+鏈表）數據結構。特點：鍵是"弱鍵"。

2、HashMap<K,V>

　　HashMap中的Entry對象是無序排列的。此類不保證映射的順序，特別是它不保證該順序恆久不變。

　　代碼示例：三種遍歷方式

public class Main {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("A", "1");
        map.put("B", "2");
        map.put("c", "3");

        // 1.獲取鍵集：keySet()
        final Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println("keySet()----" + key + "----" + map.get(key));
        }

        // 2.獲取值集：values()
        final Collection<String> values = map.values();
        for (String value : values) {
            System.out.println("values()----" + value);
        }

        // 3.獲取entry集：entrySet()
        final Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println("entrySet()----" + entry.getKey() + "----" + entry.getValue());
        }
    }
}

3、Hashtable<K,V>

4、TreeMap<K,V>

　　向TreeMap中添加key-value，要求key①必須是相同類型的對象。②必須可排序。用於給map集合中的鍵按指定屬性進行排序。
　　代碼示例：讓User具有可比性，自然排序：Comparable

public class User implements Comparable<User> {
    private String name;
    private int age;

    // 無參構造器
    // 有參構造器
    // getter & setter
    // toString()
    // 可以不復寫equals、hashCode

    // 年齡從小到大排列
    @Override
    public int compareTo(User user) {
        System.out.println(this.name + "---------" + user.getName());
        return Integer.compare(this.age, user.age);
    }
}

// 測試類
public static void main(String[] args) {
    TreeMap<User, Integer> treeMap = new TreeMap<>();
    User u1 = new User("Tom", 23);
    User u2 = new User("Jerry", 32);
    User u3 = new User("Jack", 20);
    User u4 = new User("Rose", 18);

    treeMap.put(u1, 98);
    treeMap.put(u2, 89);
    treeMap.put(u3, 76);
    treeMap.put(u4, 100);

    for (Map.Entry<User, Integer> entry : treeMap.entrySet()) {
        System.out.println(entry.getKey() + "---->" + entry.getValue());
    }
}

// 結果
Tom---------Tom
Jerry---------Tom
Jack---------Tom
Rose---------Tom
Rose---------Jack
User{name='Rose', age=18}---->100
User{name='Jack', age=20}---->76
User{name='Tom', age=23}---->98
User{name='Jerry', age=32}---->89

　　結果分析：按鍵 User 指定屬性 age 排序，不難理解打印結果的比較次數。排序二叉樹：

　　代碼示例：指定比較器，定制排序：Comparator

// 比較器
public static void main(String[] args) {
    TreeMap<User, Integer> treeMap = new TreeMap<>(new Comparator<User>() {
        @Override
        public int compare(User u1, User u2) {
            return Integer.compare(u1.getAge(), u2.getAge());
        }
    });

    User u1 = new User("Tom", 23);
    User u2 = new User("Jerry", 32);
    User u3 = new User("Jack", 20);
    User u4 = new User("Rose", 18);

    treeMap.put(u1, 98);
    treeMap.put(u2, 89);
    treeMap.put(u3, 76);
    treeMap.put(u4, 100);

    for (Map.Entry<User, Integer> entry : treeMap.entrySet()) {
        System.out.println(entry.getKey() + "---->" + entry.getValue());
    }
}

// 結果.和自然排序的結果一致.
User{name='Rose', age=18}---->100
User{name='Jack', age=20}---->76
User{name='Tom', age=23}---->98
User{name='Jerry', age=32}---->89

5、Properties

　　常用來處理配置文件。key和value都是String類型。
　　代碼示例：讀取屬性文件

// jdbc.properties
name=Tom
password=abc123

// 未關閉資源
public static void main(String[] args) throws Exception {
    Properties pros = new Properties();

    FileInputStream fis = new FileInputStream("jdbc.properties");
    pros.load(fis);

    String name = pros.getProperty("name");
    String password = pros.getProperty("password");

    System.out.println("name = " + name + ", password = " + password);
}

// 結果
name = Tom, password = abc123

6、ConcurrentHashMap<K,V>

　　請查看標簽：JDK源碼。