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​​有专门的介绍，具体参考文章：

• ​​Java集合List系列（一）：ArrayList源码解析（JDK1.8)​​

• ​​Java集合List系列（二）：LinkedList源码解析（JDK1.8）​​

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;
    }
}

工具类

总结

更多内容详见微信公众号：Python研究所