集合源码详记(jdk1.8)

集合框架整体结构图：

参考：Collection和Map接口类的层次关系–JDk1.8 最新图解

数组存储存在弊端：

1. 数组一旦初始化，其长度就不可修改
2. 数组中提供的方法非常限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
3. 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
4. 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

而是用集合存储姐可以解决上述问题

---

一、Collection接口

单列集合，用来存储一个一个的对象

1.1、List接口

特点：存储有序的、可重复的数据。

1.1.1 ArrayList

作为List接口的主要实现类；线程不安全的，效率高；jdk1.2才有的
这里可以直接参考我之前的一篇文章：ArrayList 的实现原理

特点：

1. 排列有序可重复
2. 底层使用数组
3. 速度快，但是增删慢
4. 线程不安全
5. 扩容机制：当容量不够时，容量扩大为1.5倍，扩容1.5倍仍然不够的情况下，则将原来数组的长度与新添加的集合的长度相加作为新的集合的长度

---

1.1.2 LinkedList(双向链表)

对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储；jdk1.2才有的

1、链表节点数据

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

2、构造器

// 空构造
public LinkedList() {
}
// 带参构造
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

3、添加一个节点

public boolean add(E e) {
    linkLast(e);
    return true;
}

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

4、删除一个节点

public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}


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

---

特点：

1. 排列有序可重复
2. 底层使用双向链表结构
3. 增删快，查询慢
4. 线程不安全

1.1.3 Vector

作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储；jdk1.o就有了

特点：

1. 排列有序可重复
2. 底层使用数组
3. 查询快、增删慢
4. 线程安全效率低
5. 在构造器创建对象的时候就创建了长度为10的数组
6. 扩容为原来的1倍

---

1.2、Set接口

无序的、不可重复的元素

1.2.1 HashSet

jdk1.2开始有的

无序性：不等于随机性。存储的数据在底层数组中并非照数组索引的顺序添加，而是根据数据的哈希值决定的。
不可重复性：保证添加的元素照equals()判断时，不能返回true.即：相同的元素只能添加一个。

1、构造器

// HashSet的底层结构是HashMap
private transient HashMap<E,Object> map;
// 1.无参构造器
public HashSet() {
    map = new HashMap<>();
}

// 2.带有数据的构造器
public HashSet(Collection<? extends E> c) {
	// 如果给定 HashMap 初始容量小于 16 ，就按照 HashMap 默认的 16 初始化好了
	// 如果大于 16，就按照给定值初始化
	// HashMap 扩容的伐值的计算公式是：Map 的容量 * 0.75f，一旦达到阀值就会扩容
	// 此处用 (int) (c.size ()/.75f) + 1 来表示初始化的值
	// 这样使我们期望的大小值正好比扩容的阀值还大 1，就不会扩容，符合 HashMap 扩容的公式
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}
// 3.指定初始化大小与加载因子的构造器
public HashSet(int initialCapacity, float loadFactor) {
	// 指定初始化大小与hashmap加载因子初始化
    map = new HashMap<>(initialCapacity, loadFactor);
}

// 4.指定初始化大小的构造器
public HashSet(int initialCapacity) {	
	// 指定map大小初始化
    map = new HashMap<>(initialCapacity);
}


HashSet(int initialCapacity, float loadFactor, boolean dummy) {
	// dummy – ignored (distinguishes this constructor from other int, float constructor.)
	// 忽略这个参数，目的是与其他的构造器区分开来
	// 注意这里是LinkedHashMap
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

HashSet的底层是HashMap，key是就是HashSet存储的值，value就object对象

2、添加一个元素

// object对象：HashMap的value
private static final Object PRESENT = new Object();

public boolean add(E e) {
	// 调用HashMap的put方法,put方法详见map接口
    return map.put(e, PRESENT)==null;
}

3、删除一个元素

public boolean remove(Object o) {
	// 调用的HashMap的删除
    return map.remove(o)==PRESENT;
}

HashSet的底层实现都是使用HashMap，具体细节代码见HashMap的源码解析
特点：

1. 无序不可重复
2. 底层使用hash表实现
3. 存储速度快
4. 内部是HashMap

1.2.1.1 LinkedHashSet

LinkedHashSet继承于HashSet；jdk1.4开始有的

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {

    private static final long serialVersionUID = -2851667679971038690L;

    public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);
    }

    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);
    }
    
    public LinkedHashSet() {
        super(16, .75f, true);
    }


    public LinkedHashSet(Collection<? extends E> c) {
        super(Math.max(2*c.size(), 11), .75f, true);
        addAll(c);
    }

    @Override
    public Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.DISTINCT | Spliterator.ORDERED);
    }
}

// 都会调用HashSet的这个构造方法
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

// 而底层又是使用的LinkedHashMap
public LinkedHashMap(int initialCapacity, float loadFactor) {
    super(initialCapacity, loadFactor);
    accessOrder = false;
}

详细源码见LinkedHashMap源码解析
特点：

1. 采用hash表存储
2. 内部是LinkedHashMap
3. 无序不可重复

1.2.2 TreeSet

jdk1.2开始有的
构造器

private transient NavigableMap<E,Object> m;

TreeSet(NavigableMap<E,Object> m) {
    this.m = m;
}
    
public TreeSet() {
    this(new TreeMap<E,Object>());
}

public TreeSet(Comparator<? super E> comparator) {
    this(new TreeMap<>(comparator));
}

public TreeSet(Collection<? extends E> c) {
    this();
    addAll(c);
}

public TreeSet(SortedSet<E> s) {
    this(s.comparator());
    addAll(s);
}

可见TreeSet的底层实现是TreeMap
特点：

1. 无序不可重复
2. 底层使用二叉树实现
3. 排序存储
4. 内部是TreeMap的SortedSet

---

二、Map接口

双列数据，存储key-value对的数据

---

2.1、HashMap

作为Map的主要实现类（jdk1.2开始有的）；线程不安全的，效率高；存储null的key和value

1. 构造器

	/**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
	// 默认最大容量，如果有参数的构造函数隐式指定了更高的值，则使用
    static final int MAXIMUM_CAPACITY = 1 << 30;
    
   	/**
     * The load factor used when none specified in constructor.
     */ 
    // 默认加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * The load factor for the hash table.
     *
     * @serial
     */
     // 记载因子
	final float loadFactor;
	
	// The next size value at which to resize (capacity * load factor).
	// 阈值：计算方式：容量*加载因子
	int threshold;

	// 1. 带有initialCapacity(初始化容量大小)与loadFactor(加载因子)的构造器
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        // 计算阈值
        this.threshold = tableSizeFor(initialCapacity);
    }
    
    // 2. 带有初始化容量的构造器
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    
    // 3.无参构造器
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
	
	// 4. 带有数据的map初始化
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

其中涉及到的常量：
DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
MAXIMUM_CAPACITY ： HashMap的最大支持容量，2^30
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树
UNTREEIFY_THRESHOLD：Bucket中红黑树存储的Node小于该默认值，转化为链表
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量。（当桶中Node的 数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行 resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4 倍。）
table：存储元素的数组，总是2的n次幂
entrySet：存储具体元素的集
size：HashMap中存储的键值对的数量
modCount：HashMap扩容和结构改变的次数。
threshold：扩容的临界值，=容量*记载因子
loadFactor：加载因子

2. 存储结构

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

HashMap的底层结构是node的数组
实际上不止是数组，真实的数据结构是：数组+链表+红黑树

3. 添加元素

// 二叉树阈值
static final int TREEIFY_THRESHOLD = 8;

// 添加方法
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

// 计算hash值
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

// 计算hashcode值，hashcode代表对象的内存地址
public native int hashCode();

// 这个表在第一次使用时初始化，并根据需要调整大小。
// 分配时，长度总是2的幂。（在某些操作中，我们还允许长度为零，以允许当前不需要的引导机制。）
transient Node<K,V>[] table;

// onlyIfAbsent – if true, don't change existing value (如果为true，则不更改现有值)
// evict – if false, the table is in creation mode. (如果为false，则表处于创建模式。)
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;

	// 表达式：i = (n - 1) & hash
	// 通过hash值计对象该在hash表中的位置，为null就存放值
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
    // 计算的位置如果存在值则进行一下计算
        Node<K,V> e; K k;
        // 比较hash值是否一样并且key是否一样且key不是null
        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) {
            	// 如果计算的位置的节点的next为null，则添加到next中
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    // 如果添加后链表长度大于等于阈值（开始是8）
                    // 并且在treeifyBin中判断数组长度大于64时转换成红黑树
                    // 否则进行数组扩容
                    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;
            }
        }
        // 若hash值一样，且key一样且不为null，则更新value值
        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;
}

hashcode的遵循规则：
在Java应用程序执行期间，每当在同一对象上多次调用hashCode方法时，只要不修改对象的equals比较中使用的信息，hashCode方法就必须始终返回相同的整数。从一个应用程序的一个执行到同一应用程序的另一个执行，这个整数不需要保持一致。
如果根据equals（Object）方法两个对象相等，那么对两个对象中的每个对象调用hashCode方法必须产生相同的整数结果。
根据equals（Object）方法，如果两个对象不相等，则对这两个对象中的每一个调用hashCode方法都必须产生不同的整数结果。

(面试考点)equals与hashcode的关系：

1. 如果两个对象equals相等，那么这两个对象的HashCode一定也相同
2. 如果两个对象的HashCode相同，不代表两个对象就相同，只能说明这两个对象在散列存储结构中，存放于同一个位置

总结：
HashMap在jdk1.7中的实现：

HashMap map = new HashMap()
在实例化以后，底层创建了长度是16的一维数组Entry[] table。
map.put(key1,value1)//不是第一次
首先，调用key1所在类的hashCode()计算key1的hash值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
情况1：如果此位置上的数据为空，此时的key1-value1添加成功。
情况2：如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：

情况1：如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。
情况2：如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：

情况1：如果equals()返回false:此时key1-value1添加成功。
情况2：如果equals()返回true:使用value1替换value2。

在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原的数据复制过来。

HashMap在jdk1.8的实现：

1. new HashMap():底层没创建一个长度为16的数组
2. jdk 8底层的数组是：Node[] table ,而非Entry[] table
3. 首次调用put()方法时，底层创建长度为16的数组
4. jdk7底层结构只：数组+链表。jdk8中底层结构：数组+链表+红黑树。
5. 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
6. 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

LinkedHashMap

1. 构造器

/**
 * The iteration ordering method for this linked hash map: <tt>true</tt>
 * for access-order, <tt>false</tt> for insertion-order.
 *
 * @serial
 */
 // true代表访问顺序
 // false代表插入顺序
final boolean accessOrder;
    
public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>
{

    public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }
    
    public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
    }

    public LinkedHashMap() {
        super();
        accessOrder = false;
    }

    public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super();
        accessOrder = false;
        putMapEntries(m, false);
    }

    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }
}

2. 底层结构

    /**
     * HashMap.Node subclass for normal LinkedHashMap entries.
     */
    static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

1. LinkedHashMap 是 HashMap 的子类
2. 在HashMap存储结构的基础上，使用了一对双向链表来记录添加 元素的顺序
3. 与LinkedHashSet类似，LinkedHashMap 可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致

---

2.2、Hashtable

作为古老的实现类（jdk1.0就有了）；线程安全的，效率低；不能存储null的key和value
其底层使用的是entry而非node
使用不多不在赘述

HashMap与Hashtable的异同：

1. Hashtable是线程安全的，Hash线程不安全
2. Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询 速度快，很多情况下可以互用。
3. 与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value
4. 与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序
5. Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。

Properties

常用来处理配置文件。key和value都是String类型

public class Properties extends Hashtable<Object,Object> {

---

2.3、TreeMap

1. 构造器

	//The comparator used to maintain order in this tree map, 
	//or null if it uses the natural ordering of its keys.
	// 用于维护此树映射中的顺序的比较器，如果它使用其键的自然顺序，则为null
    private final Comparator<? super K> comparator;

    public TreeMap() {
        comparator = null;
    }
    
    public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }
    
    public TreeMap(Map<? extends K, ? extends V> m) {
        comparator = null;
        putAll(m);
    }
    
    public TreeMap(Map<? extends K, ? extends V> m) {
        comparator = null;
        putAll(m);
    }
    
    public TreeMap(SortedMap<K, ? extends V> m) {
        comparator = m.comparator();
        try {
            buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
        } catch (java.io.IOException cannotHappen) {
        } catch (ClassNotFoundException cannotHappen) {
        }
    }

2. 底层结构使用entry

    static final class Entry<K,V> implements Map.Entry<K,V> {
        K key;
        V value;
        Entry<K,V> left;
        Entry<K,V> right;
        Entry<K,V> parent;
        boolean color = BLACK;

      .......
    }

总结：

1. TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。 TreeMap 可以保证所有的 Key-Value 对处于有序状态。
2. TreeSet底层使用红黑树结构存储数据
3. TreeMap 的 Key 的排序：

自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有 的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口

4. TreeMap判断两个key相等的标准：两个key通过compareTo()方法或 者compare()方法返回0。