Java集合概述篇——“上帝視角“全覽集合框架

概述

集合是Java中比較基礎的模組，所有的集合類都處於 java.util包下，其中支援多執行緒的集合類位於 java.util.concurrent包下，有興趣的朋友可以去看看相關的原始碼。

本文嘗試以全域性的角度，一窺Java集合框架的全貌；Java集合大致上可分 3 個部分，分別為： List、 Set、Map；文章會依次介紹三者各自的作用以及區別。

話不多說，Let't Go！！！

迭代器Iterator

在開始介紹具體的容器之前，讓我們先來看看迭代器為何物。迭代器提供了一種遍歷容器中元素的方式，也即是說：我們可以通過迭代器來遍歷集合元素。Iterator迭代器介面定義了迭代器所應該具有的功能，具體原始碼如下：

public interface Iterator<E> {
    /**
     * 判斷集合是否還有下一個元素
     * @return boolean
     */
    boolean hasNext();
    /**
     * 獲取下一個元素
     * @return E
     */
    E next();
    /**
     * Java8 提供的預設方法
     * 迭代的過程中不允許移除元素,會丟擲操作不支援異常
     * @throws UnsupportedOperationException
     */
    default 
 void remove() {
        throw new UnsupportedOperationException("remove");
    }
    /**
     * Java8 提供的預設方法
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

迭代器 Iterator

介面定義了迭代器應具備的功能，其中 hasNext()和 next()方法由具體的容器來實現，迭代器只能通過容器本身得到，每個容器都通過內部類實現了自己的迭代器，因此迭代器的使用方式如下：

@Test
    public void test(){
        List<Integer> list = new ArrayList<>(6);
        for (int i = 0; i < 6; i++) {
            list.add(i);
        }
        // 迭代器只能通過容器本身得到 （PS：可能有些容器會實現一些迭代器的子介面，諸如ListIterator，只是一些優化）
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

Collection

Collection是一個介面，它是一個高度抽象出來的介面，定義了集合的基本操作：新增、刪除、清空、遍歷、是否為空、獲取大小等方法。我們來看看Collection介面的類圖：

從圖中我們可以看出，Collection介面主要有 2 個子分支： List和 Set，並且定義了 AbstractCollection抽象類讓其他類繼承，AbstractCollection實現了 Collection中的絕大部分方法；我們可以看出 AbstractList和 AbstractSet都繼承於 AbstractCollection。

其次，我們看到 Collection介面依賴於 Iterator介面，（依賴關係：依賴就是一個類 A 使用到了另一個類 B，因此類 B 的變化會影響到類 A。比如某人要過河，需要借用一條船，此時人與船之間的關係就是依賴。表現在程式碼層面，為類 B 作為引數被類 A 在某個method方法中使用。）

Collection依賴於 Iterator，展現在原始碼中是 Collection介面定義了方法 Iterator<E> iterator()，用以返回集合的迭代器來遍歷集合。在 List介面中，通過 listIterator()方法返回一個 ListIterator物件；ListIterator介面是 List特有的。

Collection介面的所有子類（直接子類和間接子類）都必須實現 2 種建構函式：無參建構函式和引數為 Collection的建構函式。帶引數的建構函式可以用來轉換 Collection的型別。下面是 Collection介面中定義的API(JDK1.8)：

public interface Collection<E> extends Iterable<E> {

    // 迭代器 每個容器都通過內部類實現了迭代器
    Iterator<E> iterator();

    // 新增元素
    boolean add(E e);
    // 批量新增元素
    boolean addAll(Collection<? extends E> c);

    // 移除元素
    boolean remove(Object o);
    // 批量刪除元素
    boolean removeAll(Collection<?> c);

    // 是否包含元素o
    boolean contains(Object o);
    // 是否包含元素集
    boolean containsAll(Collection<?> c);

    // 保留元素
    boolean retainAll(Collection<?> c);

    // 獲取集合長度
    int size();
    // 集合是否為空
    boolean isEmpty();
    //轉換成陣列
    <T> T[] toArray(T[] a);
    // 清空
    void clear();

    // equals方法
    boolean equals(Object o);
    // hashCode方法
    int hashCode();

    // java8 預設方法 轉換成陣列
    default <T> T[] toArray(IntFunction<T[]> generator) {
        return toArray(generator.apply(0));
    }

    // java8 提供預設方法 滿足條件移除元素
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }


    // java8 提供的預設方法
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

List

List介面的定義如下：

public interface List<E> extends Collection<E> {
    //...
}

從 List定義中可以看出，它繼承於 Collection介面，即 List是集合的一種。List是有序的佇列，可以儲存重複元素，List中的每一個元素都有一個索引，第一個元素的索引值為0，往後的元素的索引值依次 + 1，List中允許有重複的元素。

讓我們來看看 List集合相關的類圖：

從類圖中我們看到，List介面繼承於 Collection介面，並且於下有一個抽象類 AbstractList以及後續的具體子類： ArrayList、LinkedList等。單純從這一條鏈路 List ----> AbstractList ----> ArrayList/LinkedList來看，有一股 模板方法模式 的味道，頂層介面定義好了具體行為，抽象類提供了可複用的 演算法骨架，然後具體子類根據自己的特點自定義實現相關功能。

回到 List上來，由於繼承了 Collection介面，自然包含了其所有的API，但由於 List是有序集合，所以它也有自己額外的API:

從圖中我們可以看出，List介面新增的API主要有：獲取元素的get()、設定元素的 set()、以及符合自身有序集合的指定索引index的新增元素方法 add(int, E)、還有獲取元素索引值的 indexOf相關方法等……

具體原始碼如下：

public interface List<E> extends Collection<E> {

    // Query Operations
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);

    // Modification Operations
    boolean add(E e);
    boolean remove(Object o);


    // Bulk Modification Operations
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean addAll(int index, Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);

    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

    void clear();


    // Comparison and hashing
    boolean equals(Object o);
    int hashCode();


    // Positional Access Operations
    E get(int index);
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);


    // Search Operations
    int indexOf(Object o);
    int lastIndexOf(Object o);


    // List Iterators
    ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
    List<E> subList(int fromIndex, int toIndex);
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}

AbstractList

AbstractList抽象類的定義如下：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    //....
}

從定義中我們可以看出，AbstractList繼承了 AbstractCollection抽象類，並且實現了 List介面；它實現了 List中除 get(int index)之外的大部分方法（PS：很多方法的實現細節上只是丟擲了一個UnsupportedOperationException異常，有點不太理解其含義）。

從原始碼上來看，AbstractList主要是提供了 迭代遍歷 的相關操作（通過迭代器來實現），為後續子類提供了迭代遍歷上的簡化。

AbstractSequentialList

AbstractSequentialList抽象類的定義如下：

public abstract class AbstractSequentialList<E> extends AbstractList<E> {
    // ...
}

從其定義我們看看到它繼承於 AbstractList抽象類，那它到底是做有什麼實際上的用途呢？我們來看看它的API：

我們可以看到，它所重寫的 API中大部分都含有引數：索引index。

AbstractSequentialList實現了本來只能 順序訪問/操作 的資料儲存結構（例如：連結串列）的 get(int index)、 add（int index, E element)等 隨機訪問/操作 的方法。這句話可能有點繞，稍加解釋一番：連結串列是一種只能順序訪問的資料儲存結構，而 AbstractSequentialList抽象類對這類只能 順序訪問/操作 的資料儲存結構，也提供了類陣列般的隨機訪問/操作 的能力。其底層是基於迭代器順序遍歷（說到底還是需要遍歷，只不過是它幫我們做了這一步~）來實現的。

一般情況下，對於支援隨機訪問的資料結構 (例如:ArrayList) 會繼承 AbstractList抽象類，不支援隨機訪問的資料結構（例如： LinkedList）則會繼承 AbstactSequentialList抽象類。但是需要注意的是： ArrayList和 LinkedList都大量重寫了 AbstractList和 AbstactSequentialList的相關實現，可真是任性的小朋友呀。

前朝遺孤般的Vector和Stack

在 List的類圖中，我們看到了兩個被標註為遺留的類，分別是： Vector和 Stack。

這兩個類是歷史遺留產物，在JDK的後續發展中都有想對應的替代產物，Vector是執行緒安全的 List，在實際的開發中我們可以使用 CopyOnWriteArrayList來代替；Stack提供了棧功能，我們可以使用 LinkedList來代替。

另外，關於 ArrayList和 LinkedList有專門的介紹，具體參考文章：

Set

Set的定義如下:

public interface Set<E> extends Collection<E> {
    // ...
}

從定義我們可以看出，Set介面繼承於 Collection，也是集合的一種，它代表的是數學概念中的集合——不能有重複的元素。

通過檢視原始碼可以看到，Set並沒有像 List一般定義了自己的API；Set中的所有方法都是繼承於 Collection介面。

接下來看一下集合 Set的家庭成員：

從類圖中我們可以看出，Set集合家庭中，供我們使用的主要有： TreeSet、HashSet以及 LinkedHashSet這三個類。

TreeSet：有序的存放，執行緒不安全，可以對Set集合中的元素進行排序，由紅黑樹來實現排序，TreeSet實際上也是SortedSet介面的子類，其在方法中實現了SortedSet的所有方法，並使用comparator()方法進行排序。
HashSet：底層資料結構由HashMap的鍵來實現。不保證集合中元素的順序，即不能保證迭代的順序與插入的順序一致。是執行緒不安全的。
LinkedHashSet：底層由連結串列實現，按照元素插入的順序進行迭代，即迭代輸出的順序與插入的順序保持一致。

關於這三者的詳細介紹，請參考如下文章：

todo1:
todo2:
todo3:

Map

Map的定義如下：

public interface Map<K,V> {
    // ..
}

我們可以看到，Map介面並沒有繼承於 Collection；Map是一種把鍵物件(key)和 值物件(value)進行關聯的容器。對於鍵物件(key)來說，像 Set一樣，一個Map容器中的鍵物件不允許重複，也即鍵物件key是唯一的，同時一個 鍵物件key只能對映一個 值物件value。對於 值物件value並沒有唯一性要求，理論上可以將多個 key都對映到同一個 value之上；雖然程式不會報錯，但是可能會對使用者造成困擾（到底是哪個key對映過來的呢？）

注意：由於 Map中作為 key的物件將通過計算其雜湊函式來確定與之對應的存放 value的位置，因此任何作為 key的物件都必須實現hashCode和 equals方法。

我們來看看 Map集合的家庭成員有哪些：

從類圖中我們可以看出，Map系列集合提供的可供使用的子類有 6 個，分別為： HashMap、LinkedHashMap、 WeakHashMap、HashTable(前朝遺孤)、IdentityHashMap以及 TreeMap；而實際的開發中，使用最為頻繁的為： HashMap、LinkedHashMap以及 TreeMap。

後續的文章也會針對這 3 個 Map進行原始碼分析。

Map作為一個集合，所提供的功能始終跳不出這幾種：新增、刪除、查詢等……我們來瞅瞅JDK設計者為其設計了哪些具體的API吧！

public interface Map<K,V> {

    // 返回集合長度
    int size();

    // 判斷集合是否為空
    boolean isEmpty();

    // 是否包含指定的key
    boolean containsKey(Object key);

    // 是否包含指定value
    boolean containsValue(Object value);

    // 通過key獲取對應的value
    V get(Object key);

    // Modification Operations

    // 往集合map中新增 key和value
    V put(K key, V value);

    // 根據key移除鍵值對，並返回對應的value
    V remove(Object key);


    // Bulk Operations
    // 批量新增key
    void putAll(Map<? extends K, ? extends V> m);

    // 清除集合map中的所有鍵值對
    void clear();

    // Views

    // 獲取key的集合
    Set<K> keySet();

    Collection<V> values();

    Set<Map.Entry<K, V>> entrySet();

    // entry是儲存的鍵值對物件
    interface Entry<K,V> {

        K getKey();

  
        V getValue();

        V setValue(V value);

        boolean equals(Object o);

        int hashCode();

        public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }

        public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getValue().compareTo(c2.getValue());
        }

        public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
        }

        public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
        }
    }

    // Comparison and hashing

    boolean equals(Object o);

    int hashCode();

    // Defaultable methods

    default V getOrDefault(Object key, V defaultValue) {
        V v;
        return (((v = get(key)) != null) || containsKey(key))
            ? v
            : defaultValue;
    }

    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) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

    default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
        Objects.requireNonNull(function);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }

            // ise thrown from function is not a cme.
            v = function.apply(k, v);

            try {
                entry.setValue(v);
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
        }
    }

    default V putIfAbsent(K key, V value) {
        V v = get(key);
        if (v == null) {
            v = put(key, value);
        }

        return v;
    }

    default boolean remove(Object key, Object value) {
        Object curValue = get(key);
        if (!Objects.equals(curValue, value) ||
            (curValue == null && !containsKey(key))) {
            return false;
        }
        remove(key);
        return true;
    }


    default boolean replace(K key, V oldValue, V newValue) {
        Object curValue = get(key);
        if (!Objects.equals(curValue, oldValue) ||
            (curValue == null && !containsKey(key))) {
            return false;
        }
        put(key, newValue);
        return true;
    }


    default V replace(K key, V value) {
        V curValue;
        if (((curValue = get(key)) != null) || containsKey(key)) {
            curValue = put(key, value);
        }
        return curValue;
    }

    default V computeIfAbsent(K key,
            Function<? super K, ? extends V> mappingFunction) {
        Objects.requireNonNull(mappingFunction);
        V v;
        if ((v = get(key)) == null) {
            V newValue;
            if ((newValue = mappingFunction.apply(key)) != null) {
                put(key, newValue);
                return newValue;
            }
        }

        return v;
    }


    default V computeIfPresent(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        V oldValue;
        if ((oldValue = get(key)) != null) {
            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue != null) {
                put(key, newValue);
                return newValue;
            } else {
                remove(key);
                return null;
            }
        } else {
            return null;
        }
    }


    default V compute(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        V oldValue = get(key);

        V newValue = remappingFunction.apply(key, oldValue);
        if (newValue == null) {
            // delete mapping
            if (oldValue != null || containsKey(key)) {
                // something to remove
                remove(key);
                return null;
            } else {
                // nothing to do. Leave things as they were.
                return null;
            }
        } else {
            // add or replace old mapping
            put(key, newValue);
            return newValue;
        }
    }


    default V merge(K key, V value,
            BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        V oldValue = get(key);
        V newValue = (oldValue == null) ? value :
                   remappingFunction.apply(oldValue, value);
        if(newValue == null) {
            remove(key);
        } else {
            put(key, newValue);
        }
        return newValue;
    }
}

Java集合概述篇——“上帝視角“全覽集合框架

概述

迭代器Iterator

Collection

List

AbstractList

AbstractSequentialList

前朝遺孤般的Vector和Stack

Set

Map

工具類

總結

Java集合概述篇——“上帝視角“全覽集合框架

恕我直言你可能真的不會java第7篇：像使用SQL一樣排序集合

恕我直言你可能真的不會java第10篇-集合元素歸約

ArrayList集合概述和基本使用---Java

【Java集合】1 集合概述

Java 基礎(理論篇)

【Java】基礎篇-排序二叉樹

Java SE基礎鞏固（四）：集合類

Java使用Iterator迭代器遍歷集合資料的方法小結

Java如何使用Iterator迭代器刪除集合重複選項

Java底層基於二叉搜尋樹實現集合和對映/集合Set功能詳解

恕我直言你可能真的不會java第5篇：Stream的狀態與並行操作

恕我直言你可能真的不會java第6篇：Stream效能差？不要人云亦云

Java資料結構系列（2）——List集合

恕我直言你可能真的不會java第8篇-函式式介面

恕我直言你可能真的不會java第9篇-Stream元素的匹配與查詢

恕我直言你可能真的不會java第11篇-Stream API終端操作

Java高併發篇

恕我直言你可能真的不會java第12篇-如何使用Stream API對Map型別元素排序

Java語言概述

Java集合概述篇——“上帝視角“全覽集合框架

相關推薦