本篇文章带你从Java源码深入解析关于Java容器的概念。

参考文献：

1. Java容器相关知识全面总结

2. Java官方API文档

1 常用容器继承关系图

先上一张网上的继承关系图

集合继承关系图

个人觉得有些地方不是很准确，比如Iterator不是容器，只是一个操作遍历集合的方法接口，所以不应该放在里面。并且Map不应该继承自Collection。所以自己整理了一个常用继承关系图如下

New集合继承关系图

如上图所示，接下去会自顶向下解释重要的接口和实现类。

2 Collection和Map

在Java容器中一共定义了2种集合, 顶层接口分别是Collection和Map。但是这2个接口都不能直接被实现使用，分别代表两种不同类型的容器。

简单来看，Collection代表的是单个元素对象的序列，（可以有序/无序，可重复/不可重复 等，具体依据具体的子接口Set，List，Queue等）；Map代表的是“键值对”对象的集合（同样可以有序/无序 等依据具体实现）

2.1 Collection

根据Java官方文档对Collection的解释

The root interface in the collection hierarchy. A collection represents a group of objects, known as its elements. Some collections allow duplicate elements and others do not. Some are ordered and others unordered. The JDK does not provide any direct implementations of this interface: it provides implementations of more specific subinterfaces like Set and List. This interface is typically used to pass collections around and manipulate them where maximum generality is desired.

大概意思就是

是容器继承关系中的顶层接口。是一组对象元素组。有些容器允许重复元素有的不允许，有些有序有些无序。 JDK不直接提供对于这个接口的实现，但是提供继承与该接口的子接口比如 List Set。这个接口的设计目的是希望能最大程度抽象出元素的操作。

接口定义：

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

    ...
    
}

泛型<E>即该Collection中元素对象的类型，继承的Iterable是定义的一个遍历操作接口，采用hasNext next的方式进行遍历。具体实现还是放在具体类中去实现。

我们可以看下定义的几个重要的接口方法

add(E e) 
 Ensures that this collection contains the specified element
 
clear()
 Removes all of the elements from this collection (optional operation).
 
contains(Object o)
 Returns true if this collection contains the specified element.
 
isEmpty()
 Returns true if this collection contains no elements.
 
iterator()
 Returns an iterator over the elements in this collection.
 
remove(Object o)
 Removes a single instance of the specified element from this collection, if it is present (optional operation).
 
retainAll(Collection<?> c)
 Retains only the elements in this collection that are contained in the specified collection (optional operation).（**ps:这个平时倒是没注意，感觉挺好用的接口，保留指定的集合**）
 
size()
 Returns the number of elements in this collection.
 
toArray()
 Returns an array containing all of the elements in this collection.
 
toArray(T[] a)
 Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.（**ps:这个接口也可以mark下**）
 
 ...

上面定义的接口就代表了Collection这一类容器最基本的操作，包括了插入，移除，查询等，会发现都是对单个元素的操作，Collection这类集合即元素对象的存储。其中有2个接口平时没用过但是觉得很有用

1. retainAll(Collection<?> c) 保留指定的集合
2. toArray(T[] a) 可以转为数组

2.2 Map

Java官方文档对Map的解释

An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value.

This interface takes the place of the Dictionary class, which was a totally abstract class rather than an interface.

The Map interface provides three collection views, which allow a map's contents to be viewed as a set of keys, collection of values, or set of key-value mappings. The order of a map is defined as the order in which the iterators on the map's collection views return their elements. Some map implementations, like the TreeMap class, make specific guarantees as to their order; others, like the HashMap class, do not.

大概意思就是

一个保存键值映射的对象。 映射Map中不能包含重复的key，每一个key最多对应一个value。

这个接口替代了原来的一个抽象类Dictionary。

Map集合提供3种遍历访问方法，1.获得所有key的集合然后通过key访问value。2.获得value的集合。3.获得key-value键值对的集合（key-value键值对其实是一个对象，里面分别有key和value）。 Map的访问顺序取决于Map的遍历访问方法的遍历顺序。 有的Map，比如TreeMap可以保证访问顺序，但是有的比如HashMap，无法保证访问顺序。

接口定义如下：

public interface Map<K,V> {

    ...
    
    interface Entry<K,V> {
        K getKey();
        V getValue();
        ...
    } 
}

泛型<K,V>分别代表key和value的类型。这时候注意到还定义了一个内部接口Entry，其实每一个键值对都是一个Entry的实例关系对象，所以Map实际其实就是Entry的一个Collection，然后Entry里面包含key，value。再设定key不重复的规则，自然就演化成了Map。（个人理解）

下面介绍下定义的3个遍历Map的方法。

1. Set<K> keySet()

会返回所有key的Set集合，因为key不可以重复，所以返回的是Set格式，而不是List格式。（之后会说明Set，List区别。这里先告诉一点Set集合内元素是不可以重复的，而List内是可以重复的） 获取到所有key的Set集合后，由于Set是Collection类型的，所以可以通过Iterator去遍历所有的key，然后再通过get方法获取value。如下

Map<String,String> map = new HashMap<String,String>();
map.put("01", "zhangsan");
map.put("02", "lisi");
map.put("03", "wangwu");

Set<String> keySet = map.keySet();//先获取map集合的所有键的Set集合
Iterator<String> it = keySet.iterator();//有了Set集合，就可以获取其迭代器。

while(it.hasNext()) {
       String key = it.next();
       String value = map.get(key);//有了键可以通过map集合的get方法获取其对应的值。
       System.out.println("key: "+key+"-->value: "+value);//获得key和value值
}

2. Collection<V> values()

直接获取values的集合，无法再获取到key。所以如果只需要value的场景可以用这个方法。获取到后使用Iterator去遍历所有的value。如下

Map<String,String> map = new HashMap<String,String>();
map.put("01", "zhangsan");
map.put("02", "lisi");
map.put("03", "wangwu");

Collection<String> collection = map.values();//返回值是个值的Collection集合
System.out.println(collection);

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

是将整个Entry对象作为元素返回所有的数据。然后遍历Entry，分别再通过getKey和getValue获取key和value。如下

Map<String,String> map = new HashMap<String,String>();
map.put("01", "zhangsan");
map.put("02", "lisi");
map.put("03", "wangwu");

//通过entrySet()方法将map集合中的映射关系取出（这个关系就是Map.Entry类型）
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//将关系集合entrySet进行迭代，存放到迭代器中                
Iterator<Map.Entry<String, String>> it = entrySet.iterator();

while(it.hasNext()) {
       Map.Entry<String, String> me = it.next();//获取Map.Entry关系对象me
       String key = me.getKey();//通过关系对象获取key
       String value = me.getValue();//通过关系对象获取value
}

通过以上3种遍历方式我们可以知道，如果你只想获取key，建议使用keySet。如果只想获取value，建议使用values。如果key value希望遍历，建议使用entrySet。（虽然通过keySet可以获得key再间接获得value，但是效率没entrySet高，不建议使用这种方法）

3 List、Set和Queue

在Collection这个集成链中，我们介绍List、Set和Queue。其中会重点介绍List和Set以及几个常用实现class。Queue平时实在没用过。

先简单概述下List和Set。他们2个是继承Collection的子接口，就是说他们也都是负责存储单个元素的容器。但是最大的区别如下

1. List是存储的元素容器是有个有序的可以索引到元素的容器，并且里面的元素可以重复。
2. Set里面和List最大的区别是Set里面的元素对象不可重复。

3.1 List

Java文档中介绍

An ordered collection (also known as a sequence). The user of this interface has precise control over where in the list each element is inserted. The user can access elements by their integer index (position in the list), and search for elements in the list.

Unlike sets, lists typically allow duplicate elements. More formally, lists typically allow pairs of elements e1 and e2 such that e1.equals(e2), and they typically allow multiple null elements if they allow null elements at all. It is not inconceivable that someone might wish to implement a list that prohibits duplicates, by throwing runtime exceptions when the user attempts to insert them, but we expect this usage to be rare.

...

The List interface provides a special iterator, called a ListIterator, that allows element insertion and replacement, and bidirectional access in addition to the normal operations that the Iterator interface provides. A method is provided to obtain a list iterator that starts at a specified position in the list.

大概意思是

一个有序的Collection（或者叫做序列）。使用这个接口可以精确掌控元素的插入，还可以根据index获取相应位置的元素。

不像Set，list允许重复元素的插入。有人希望自己实现一个list，禁止重复元素，并且在重复元素插入的时候抛出异常，但是我们不建议这么做。

...

List提供了一种特殊的iterator遍历器，叫做ListIterator。这种遍历器允许遍历时插入，替换，删除，双向访问。 并且还有一个重载方法允许从一个指定位置开始遍历。

然后我们再看下List接口新增的接口，会发现add，get这些都多了index参数，说明在原来Collection的基础上，List是一个可以指定索引，有序的容器。在这注意以下添加的2个新Iteractor方法。

ListIterator<E> listIterator();

ListIterator<E> listIterator(int index);

我们再看ListIterator的代码

public interface ListIterator<E> extends Iterator<E> {
    // Query Operations
    
    boolean hasNext();

    E next();

    boolean hasPrevious();

    E previous();

    int previousIndex();

    void remove();

    void set(E e);

    void add(E e);
}

一个集合在遍历过程中进行插入删除操作很容易造成错误，特别是无序队列，是无法在遍历过程中进行这些操作的。但是List是一个有序集合，所以在这实现了一个ListIteractor，可以在遍历过程中进行元素操作，并且可以双向访问。

这个是之前开发中一直没有发现的，好东西。mark

以上就是List的基本概念和规则，下面我们介绍2个常用List的实现类，ArrayList和LinkedList。

3.1.1 ArrayList

就Java文档的解释，整理出以下几点特点：

1. ArrayList是一个实现了List接口的可变数组
2. 可以插入null
3. 它的size, isEmpty, get, set, iterator,add这些方法的时间复杂度是O(1),如果add n个数据则时间复杂度是O(n).
4. ArrayList不是synchronized的。

然后我们来简单看下ArrayList源码实现。这里只写部分源码分析。

所有元素都是保存在一个Object数组中，然后通过size控制长度。

transient Object[] elementData;

private int size;

这时候看下add的代码分析

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

其实在每次add的时候会判断数据长度，如果不够的话会调用Arrays.copyOf，复制一份更长的数组，并把前面的数据放进去。

我们再看下remove的代码是如何实现的。

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

其实就是直接使用System.arraycopy把需要删除index后面的都往前移一位然后再把最后一个去掉。

PS：终于发现以前学习的数据结构用到用场了。O。O

3.1.2 LinkedList

LinkedList是一个链表维护的序列容器。和ArrayList都是序列容器，一个使用数组存储，一个使用链表存储。

数组和链表2种数据结构的对比：

1. 查找方面。数组的效率更高，可以直接索引出查找，而链表必须从头查找。
2. 插入删除方面。特别是在中间进行插入删除，这时候链表体现出了极大的便利性，只需要在插入或者删除的地方断掉链然后插入或者移除元素，然后再将前后链重新组装，但是数组必须重新复制一份将所有数据后移或者前移。
3. 在内存申请方面，当数组达到初始的申请长度后，需要重新申请一个更大的数组然后把数据迁移过去才行。而链表只需要动态创建即可。

如上LinkedList和ArrayList的区别也就在此。根据使用场景选择更加适合的List。

下面简单展示LinkedList的部分源码解析。

首先是链表的节点的定义,非常简单的一个双向链表。

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

然后每个LinkedList中会持有链表的头指针和尾指针

transient int size = 0;

transient Node<E> first;

transient Node<E> last;

列举最基本的插入和删除的链表操作

private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}
    
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    final E element = l.item;
    final Node<E> prev = l.prev;
    l.item = null;
    l.prev = null; // help GC
    last = prev;
    if (prev == null)
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}

E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

上面6个方法就是链表的核心，头尾中间插入，头尾中间删除。其他对外的调用都是围绕这几个方法进行操作的

同时LinkedList还实现了Deque接口，Deque接口是继承Queue的。所以LinkedList还支持队列的pop，push，peek操作。

总结

3.2 Set

Set的核心概念就是集合内所有元素不重复。在Set这个子接口中没有在Collection特别实现什么额外的方法，应该只是定义了一个Set概念。下面我们来看Set的几个常用的实现HashSet、LinkedHashSet、TreeSet

3.2.1 HashSet

HashSet的核心概念。Java文档中描述

This class implements the Set interface, backed by a hash table (actually a HashMap instance). It makes no guarantees as to the iteration order of the set; in particular, it does not guarantee that the order will remain constant over time. This class permits the null element.

大概意思是

HashSet实现了Set接口，基于HashMap进行存储。遍历时不保证顺序，并且不保证下次遍历的顺序和之前一样。HashSet中允许null元素。

进入到HashSet源码中我们发现，所有数据存储在

private transient HashMap<E,Object> map;

private static final Object PRESENT = new Object();

意思就是HashSet的集合其实就是HashMap的key的集合，然后HashMap的val默认都是PRESENT。HashMap的定义即是key不重复的集合。使用HashMap实现，这样HashSet就不需要再实现一遍。

所以所有的add，remove等操作其实都是HashMap的add、remove操作。遍历操作其实就是HashMap的keySet的遍历,举例如下

...
public Iterator<E> iterator() {
    return map.keySet().iterator();
}

public boolean contains(Object o) {
    return map.containsKey(o);
}

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

public void clear() {
    map.clear();
}
...

3.2.2 LinkedHashSet

LinkedHashSet的核心概念相对于HashSet来说就是一个可以保持顺序的Set集合。HashSet是无序的，LinkedHashSet会根据add，remove这些操作的顺序在遍历时返回固定的集合顺序。这个顺序不是元素的大小顺序，而是可以保证2次遍历的顺序是一样的。

类似HashSet基于HashMap的源码实现，LinkedHashSet的数据结构是基于LinkedHashMap。过多的就不说了。

3.2.3 TreeSet

TreeSet即是一组有次序的集合，如果没有指定排序规则Comparator，则会按照自然排序。（自然排序即e1.compareTo(e2) == 0作为比较）

注意：TreeSet内的元素必须实现Comparable接口。

TreeSet源码的算法即基于TreeMap，具体算法在说明TreeMap的时候进行解释。

总结

4 HashMap、LinkedHashMap、TreeMap和WeakHashMap

4.1 HashMap

HashMap就是最基础最常用的一种Map，它无序，以散列表的方式进行存储。之前提到过，HashSet就是基于HashMap，只使用了HashMap的key作为单个元素存储。

HashMap的访问方式就是继承于Map的最基础的3种方式，详细见上。在这里我具体分析一下HashMap的底层数据结构的实现。

在看HashMap源码前，先理解一下他的存储方式-散列表（哈希表）。像之前提到过的用数组存储，用链表存储。哈希表是使用数组和链表的组合的方式进行存储。(具体哈希表的概念自行搜索)如下图就是HashMap采用的存储方法。

哈希散列表

hash得到数值，放到数组中，如果遇到冲突则以链表方式挂在下方。

HashMap的存储定义是

transient Node<K,V>[] table;

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
}

数组table存放元素，如果遇到冲突下挂到冲突元素的next链表上。

在这我们可以看下get核心方法和put核心方法的源码

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

上面代码中看出先根据hash值和数组长度作且运算得出下标索引。如果存在判断hash值是否完全一致，如果不完全一致则next链表向下找一致的hash值。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

上面是put的核心源码，即查找hash值所在索引是否有元素，没有的话new一个Node直接放在table中。如果已经有Node了，就遍历该Node的next，将新元素放到最后。

HashMap的遍历，是从数组遍历第一个非空的元素，然后再根据这个元素访问其next下的所有Node。因为第一个元素不是一定从数组的0开始，所以HashMap是无序遍历。

4.2 LinkedHashMap

LinkedHashMap相对于HashMap来说区别是，LinkedHashMap遍历的时候具有顺序，可以保存插入的顺序，（还可以设置最近访问的元素也放在前面，即LRU）

其实LinkedHashMap的存储还是跟HashMap一样，采用哈希表方法存储，只不过LinkedHashMap多维护了一份head，tail链表。

transient LinkedHashMap.Entry<K,V> head;

transient LinkedHashMap.Entry<K,V> tail;

即在创建新Node的时候将新Node放到最后，这样遍历的时候不再像HashMap一样，从数组开始判断第一个非空元素，而是直接从表头进行遍历。这样即满足有序遍历。

4.3 TreeMap

TreeMap平时用的不多，TreeMap会实现SortMap接口，定义一个排序规则，这样当遍历TreeMap的时候，会根据规定的排序规则返回元素。

4.4 WeakHashMap

WeakHashMap，此种Map的特点是，当除了自身有对key的引用外，此key没有其他引用那么此map会自动丢弃此值，

举例：声明了两个Map对象，一个是HashMap，一个是WeakHashMap，同时向两个map中放入a、b两个对象，当HashMap remove掉a 并且将a、b都指向null时，WeakHashMap中的a将自动被回收掉。出现这个状况的原因是，对于a对象而言，当HashMap remove掉并且将a指向null后，除了WeakHashMap中还保存a外已经没有指向a的指针了，所以WeakHashMap会自动舍弃掉a，而对于b对象虽然指向了null，但HashMap中还有指向b的指针，所以
WeakHashMap将会保留。

WeakHashMap用的也不多，在这简单提及。

总结

结尾

以上就是对于Java集合的完整分析和源码解析。其中ArrayList、HashMap使用较多，当考虑到效率时记得有Linded系列集合和WeakHashMap。Over~~

更多文章关注我的公众号

我的公众号