Java集合源码解析

 一.Collection集合体系

 List

ArrayList底层原理

jdk7版本：

    ArrayList list = new ArrayList();//初始化底层的elementData的Object[]数组，长度为10.
    list.add(123);//elementData[0] = new Integer(123);
    list.add("AA");//一旦添加的数据的个数超出了底层数组的长度10，需要考虑扩容。
                   //默认容量扩容扩容为原来的1.5倍，同时将旧数组中的数据都复制到新的数组中。

实例化与add()方法

    private static final int DEFAULT_CAPACITY = 10;//默认初始容量10
	private static final Object[] EMPTY_ELEMENTDATA = {};
	public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;//数组初始化为一个空数组
    }
    public boolean add(E e) {
        //查看当前数组是否够多存一个元素
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {//如果当前数组还是空数组
            //minCapacity按照 默认初始容量和minCapacity中的的最大值处理
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
		//看是否需要扩容处理
        ensureExplicitCapacity(minCapacity);
    }
	//...

 jdk1.6版本:

    public ArrayList() {
		this(10);//指定初始容量为10
    }
    public ArrayList(int initialCapacity) {
		super();
        //检查初始容量的合法性
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //数组初始化为长度为initialCapacity的数组
		this.elementData = new Object[initialCapacity];
    }

jdk8版本:

ArrayList list = new ArrayList();//初始化底层elementData的Object[]数组为{}
list.add(123);//此时底层创建长度为10的elementData数组，并将new Integer(123)存放到角标0的索引位置。
list.add("AA");//一旦添加的数据的个数超出了底层数组的长度10，需要考虑扩容。
               //默认容量扩容扩容为原来的1.5倍，同时将旧数组中的数据都复制到新的数组中。
理解类比：jdk7之前中ArrayList的类似于单例模式的饿汉式.
         jdk8中ArrayList的类似于单例模式的懒汉式.

实例化与add()方法

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//初始化为空数组
    }
    public boolean add(E e) {
        //查看当前数组是否够多存一个元素
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        
        //存入新元素到[size]位置，然后size自增1
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) {
        //如果当前数组还是空数组
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //那么minCapacity取DEFAULT_CAPACITY与minCapacity的最大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
		//查看是否需要扩容
        ensureExplicitCapacity(minCapacity);
    }
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//修改次数加1

        // 如果需要的最小容量  比  当前数组的长度  大，即当前数组不够存，就扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//当前数组容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新数组容量是旧数组容量的1.5倍
        //看旧数组的1.5倍是否够
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //看旧数组的1.5倍是否超过最大数组限制
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //复制一个新数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

remove()方法 1

    public boolean remove(Object o) {
        //先找到o在当前ArrayList的数组中的下标
        //分o是否为空两种情况讨论
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {//null值用==比较
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {//非null值用equals比较
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
    private void fastRemove(int index) {
        modCount++;//修改次数加1
        //需要移动的元素个数
        int numMoved = size - index - 1;
        
        //如果需要移动元素，就用System.arraycopy移动元素
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        
        //将elementData[size-1]位置置空，让GC回收空间，元素个数减少
        elementData[--size] = null; // clear to let GC do its work
    }

 remove()方法 2

    public E remove(int index) {
        rangeCheck(index);//检验index是否合法

        modCount++;//修改次数加1
        
        //取出[index]位置的元素，[index]位置的元素就是要被删除的元素，用于最后返回被删除的元素
        E oldValue = elementData(index);
        
		//需要移动的元素个数
        int numMoved = size - index - 1;
        
        //如果需要移动元素，就用System.arraycopy移动元素
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //将elementData[size-1]位置置空，让GC回收空间，元素个数减少
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

set()与get()方法

    public E set(int index, E element) {
        rangeCheck(index);//检验index是否合法

        //取出[index]位置的元素，[index]位置的元素就是要被替换的元素，用于最后返回被替换的元素
        E oldValue = elementData(index);
        //用element替换[index]位置的元素
        elementData[index] = element;
        return oldValue;
    }
    public E get(int index) {
        rangeCheck(index);//检验index是否合法

        return elementData(index);//返回[index]位置的元素
    }

 indexOf()与lastIndexOf()方法

    public int indexOf(Object o) {
        //分为o是否为空两种情况
        if (o == null) {
            //从前往后找
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    public int lastIndexOf(Object o) {
         //分为o是否为空两种情况
        if (o == null) {
            //从后往前找
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

Vector

  Vector的特点 实现了List接口，存储有序的、可以重复的数据。底层使用Object[] 存储。线程安全的，效率低

Vector部分源码分析

实例化

 public Vector() {
        this(10);//指定初始容量initialCapacity为10
    }
	public Vector(int initialCapacity) {
        this(initialCapacity, 0);//指定capacityIncrement增量为0
    }
    public Vector(int initialCapacity, int capacityIncrement增量为0) {
        super();
        //判断了形参初始容量initialCapacity的合法性
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //创建了一个Object[]类型的数组
        this.elementData = new Object[initialCapacity];//默认是10
        //增量，默认是0，如果是0，后面就按照2倍增加，如果不是0，后面就按照你指定的增量进行增量
        this.capacityIncrement = capacityIncrement;
    }

add()方法

//synchronized意味着线程安全的   
	public synchronized boolean add(E e) {
        modCount++;
    	//看是否需要扩容
        ensureCapacityHelper(elementCount + 1);
    	//把新的元素存入[elementCount]，存入后，elementCount元素的个数增1
        elementData[elementCount++] = e;
        return true;
    }

    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        //看是否超过了当前数组的容量
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);//扩容
    }
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//获取目前数组的长度
        //如果capacityIncrement增量是0，新容量 = oldCapacity的2倍
        //如果capacityIncrement增量是不是0，新容量 = oldCapacity + capacityIncrement增量;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        
        //如果按照上面计算的新容量还不够，就按照你指定的需要的最小容量来扩容minCapacity
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        
        //如果新容量超过了最大数组限制，那么单独处理
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        
        //把旧数组中的数据复制到新数组中，新数组的长度为newCapacity
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

remove()与indexOf

    public boolean remove(Object o) {
        return removeElement(o);
    }
    public synchronized boolean removeElement(Object obj) {
        modCount++;
        //查找obj在当前Vector中的下标
        int i = indexOf(obj);
        //如果i>=0，说明存在，删除[i]位置的元素
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }
   public synchronized void removeElementAt(int index) {
        modCount++;
        //判断下标的合法性
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        //j是要移动的元素的个数
        int j = elementCount - index - 1;
        //如果需要移动元素，就调用System.arraycopy进行移动
        if (j > 0) {
            //把index+1位置以及后面的元素往前移动
            //index+1的位置的元素移动到index位置，依次类推
            //一共移动j个
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        //元素的总个数减少
        elementCount--;
        //将elementData[elementCount]这个位置置空，用来添加新元素，位置的元素等着被GC回收
        elementData[elementCount] = null; /* to let gc do its work */
    }

    public int indexOf(Object o) {
        return indexOf(o, 0);
    }
    public synchronized int indexOf(Object o, int index) {
        if (o == null) {//要查找的元素是null值
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)//如果是null值，用==null判断
                    return i;
        } else {//要查找的元素是非null值
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))//如果是非null值，用equals判断
                    return i;
        }
        return -1;
    }

ArrayList与Vector的区别？

它们的底层物理结构都是数组，我们称为动态数组。

• ArrayList是新版的动态数组，线程不安全，效率高，Vector是旧版的动态数组，线程安全，效率低。

• 动态数组的扩容机制不同，ArrayList扩容为原来的1.5倍，Vector扩容增加为原来的2倍。

• 数组的初始化容量，如果在构建ArrayList与Vector的集合对象时，没有显式指定初始化容量，那么Vector的内部数组的初始容量默认为10，而ArrayList在JDK1.6及之前的版本也是10，JDK1.7之后的版本ArrayList初始化为长度为0的空数组，之后在添加第一个元素时，再创建长度为10的数组。

  • 用的时候，再创建数组，避免浪费。因为很多方法的返回值是ArrayList类型，需要返回一个ArrayList的对象，例如：后期从数据库查询对象的方法，返回值很多就是ArrayList。有可能你要查询的数据不存在，要么返回null，要么返回一个没有元素的ArrayList对象。

LinkedList

实现了List接口，存储有序的、可以重复的数据。底层使用双向链表存储数据

	int size = 0;
	Node<E> first;//记录第一个结点的位置
	Node<E> last;//记录最后一个结点的位置

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

    public boolean add(E e) {
        linkLast(e);//默认把新元素链接到链表尾部
        return true;
    }
    void linkLast(E e) {
        final Node<E> l = last;//用l 记录原来的最后一个结点
        
        //创建新结点
        final Node<E> newNode = new Node<>(l, e, null);
        //现在的新结点是最后一个结点了
        last = newNode;
        
        //如果l==null，说明原来的链表是空的
        if (l == null)
            //那么新结点同时也是第一个结点
            first = newNode;
        else
            //否则把新结点链接到原来的最后一个结点的next中
            l.next = newNode;
        //元素个数增加
        size++;
        //修改次数增加
        modCount++;
    }

    public void add(int index, E element) {
        checkPositionIndex(index);//检查index范围

        if (index == size)//如果index==size，连接到当前链表的尾部
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

    Node<E> node(int index) {
        // assert isElementIndex(index);

        //如果index<size/2，就从前往后找目标结点
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {//否则从后往前找目标结点
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

	//把新结点插入到[index]位置的结点succ前面
    void linkBefore(E e, Node<E> succ) {//succ是[index]位置对应的结点
        // assert succ != null;
        final Node<E> pred = succ.prev; //[index]位置的前一个结点
        
        //新结点的prev是原来[index]位置的前一个结点
        //新结点的next是原来[index]位置的结点
        final Node<E> newNode = new Node<>(pred, e, succ);
        
        //[index]位置对应的结点的prev指向新结点
        succ.prev = newNode;
        
        //如果原来[index]位置对应的结点是第一个结点，那么现在新结点是第一个结点
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;//原来[index]位置的前一个结点的next指向新结点
        size++;
        modCount++;
    }

    public boolean remove(Object o) {
        //分o是否为空两种情况
        if (o == null) {
            //找到o对应的结点x
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);//删除x结点
                    return true;
                }
            }
        } else {
            //找到o对应的结点x
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);//删除x结点
                    return true;
                }
            }
        }
        return false;
    }
    E unlink(Node<E> x) {//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 {//被删除结点不是第一个结点
            //被删除结点的上一个结点的next指向被删除结点的下一个结点
            prev.next = next;
            //断开被删除结点与上一个结点的链接
            x.prev = null;//使得GC回收
        }

        //如果被删除结点的后面没有结点，说明被删除结点是最后一个结点
        if (next == null) {
            //那么被删除结点的上一个结点变为最后一个结点
            last = prev;
        } else {//被删除结点不是最后一个结点
            //被删除结点的下一个结点的prev执行被删除结点的上一个结点
            next.prev = prev;
            //断开被删除结点与下一个结点的连接
            x.next = null;//使得GC回收
        }
		//把被删除结点的数据也置空，使得GC回收
        x.item = null;
        //元素个数减少
        size--;
        //修改次数增加
        modCount++;
        //返回被删除结点的数据
        return element;
    }

ArrayList与LinkedList区别

动态数组底层的物理结构是数组，因此根据索引访问的效率非常高。但是非末尾位置的插入和删除效率不高，因为涉及到移动元素。另外添加操作时涉及到扩容问题，就会增加时空消耗。

链表底层的物理结构是链表，因此根据索引访问的效率不高，但是插入和删除不需要移动元素，只需要修改前后元素的指向关系即可，而且链表的添加不会涉及到扩容问题。

开发建议：

① 开发中对于频繁的插入、删除操作，建议使用LinkedList,效率高于ArrayList。 开发中主要做添加和获取数据的操作，以及偶尔的插入、删除操作，推荐使用ArrayList。

Set

存取无序，不可重复的，Set的内部实现其实是一个Map。即HashSet的内部实现是一个HashMap，TreeSet的内部实现是一个TreeMap，LinkedHashSet的内部实现是一个LinkedHashMap。

HashSet

HashSet:Set接口的主要实现类，可以存储null。底层使用HashMap,HashMap底层使用：数组+单向链表+红黑树(jdk8)

  Set中无序性、不可重复性的理解
    无序性：不等同于随机性。不等同添加的顺序与遍历的顺序不一致。与底层存储的位置有关，不是依次紧密排列的。
    不可重复性：
      添加元素a时，首先调用元素a所在类的hashCode()，得到此元素a的哈希值，此哈希值就决定了此元素在Set的底层的存储位置i。
          如果此位置上没有元素，则元素a添加成功。
          如果此位置上有元素b，先判断元素a与元素b的哈希值是否相等：
                1）哈希值不相等，则元素a添加成功   ---> 开始时使用链表存储，满足特定条件时，改为红黑树
                2）哈希值相等，则需要进一步判断元素a与元素b是否相同，调用元素a的equals()
                     ① 如果equals()返回true:则元素a添加不成功
                     ② 如果equals()返回false:则元素a添加成功  ---> 开始时使用链表存储，满足特定条件时，改为红黑树

HashSet源码：

public HashSet() {
        map = new HashMap<>();
    }

    public HashSet(Collection<? extends E> c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }

    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }

    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }

	//这个构造器是给子类LinkedHashSet调用的
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

LinkedHashSet

HashSet的子类，底层在HashSet的数据结构基础之上，又添加了一对链表（前后元素使用双向链表连接）对于频繁的遍历操作，性能更高

  public LinkedHashSet(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true);//调用HashSet的某个构造器
    }

    public LinkedHashSet(int initialCapacity) {
        super(initialCapacity, .75f, true);//调用HashSet的某个构造器
    }

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

    public LinkedHashSet(Collection<? extends E> c) {
        super(Math.max(2*c.size(), 11), .75f, true);//调用HashSet的某个构造器
        addAll(c);
    }

TreeSet  

 TreeSet的使用
    ① 底层使用红黑树进行的存储
    ② 向TreeSet中添加的元素，可以实现按照元素的指定的属性的大小顺序进行排序遍历
    ③ TreeSet对应的两种排序方式：
        > 自然排序：使用Comparable
        > 定制排序：使用Comparator
    ④ 向TreeSet中添加的元素必须是同一个类创建的对象。
    ⑤ TreeSet中的元素是否相同判别的唯一标准是：compareTo() 或 compare()方法。
       不再参考equals() 和 hashCode()

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

但是，咱们存到Set中只有一个元素，又是怎么变成(key,value)的呢？

以HashSet中的源码为例：

private static final Object PRESENT = new Object();
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
public Iterator<E> iterator() {
    return map.keySet().iterator();
}

原来是，把添加到Set中的元素作为内部实现map的key，然后用一个常量对象PRESENT对象，作为value。

这是因为Set的元素不可重复和Map的key不可重复有相同特点。Map有一个方法keySet()可以返回所有key。

Map

HashMap

一、对于Map集合存储结构的理解
首先介绍以HashMap为典型代表的Map集合的存储结构

① Map中的key：无序的、不可重复的，底层使用Set集合存储key；key所在的类要重写equals()和hashCode() 。

② Map中的value：无序的、可重复的，底层使用Collection集合存储value；value所在的类要重写equals() 。

③ Map中的entry：无序的、不可重复的，底层使用Set集合存储entry，每个entry都相当于一组

key-value 。

二、HashMap的常用方法
如果想要使用HashMap，我们需要对HashMap的常用方法有一个基本的了解：

* 添加：put(Object key，Object value)
* 删除：remove(Object key)
* 修改：put(Object key，Object value)
* 查询：get(Object key)
* 长度：size()
* 遍历：keySet() / values() / entrySet()

三、HashMap的内存结构说明
① HashMap在jdk7中的实现原理

HashMap对象在实例化后，底层创建了一个长度为16的一维数组 Entry[ ] table

当执行方法 put(key1，value1) 添加数据时，HashMap底层的实现原理如下（此前可能已经执行过多次put()方法）：

首先，调用key1所在类的hashCode()计算key1的哈希值，此哈希值经过底层算法的计算以后，可以得到在Entry数组中的存放位置，接下来又分为三种情况。

情况1：如果此位置上的数据为空，此时的key1-value1添加成功。

情况2：如果此位置上数据不为空（意味着此位置上存在一个或多个数据（多个数据以链表的形式存在）），则比较key1和已经存在的数据的哈希值，如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功，即key1-value1和原来的数据会以链表的形式存储。

情况3：与情况二类似，在比较key1和已经存在的数据的哈希值时，如果key1的哈希值和某个已经存在的数据（如key2-value2）的哈希值相同，则调用key1所在类的equals()方法，返回key1和key2的比较结果，如果返回的是false，此时key1-value1添加成功，同样也是和原来的数据以链表的形式存储；如果返回的是true，则会使用value1替换value2。

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

② HashMap在jdk8中相较于jdk7在底层实现方面的不同

（1）. 使用空参构造器创建HashMap对象时，底层没有直接创建一个长度为16的数组。
（2）. jdk8底层存储数据的数组使用的是Node[ ]，而不是Entry[ ] 。
（3）. jdk8在首次调用put()方法时，底层才会创建长度为16的数组。
（4）. jdk7中底层存储数据的结构是：数组+链表。jdk8中底层存储数据的结构是：数组+链表+红黑树。
（5）.当存储数据形成链表时，链表的结构不相同，jdk7的链表结构是：新的数据指向旧的数据。jdk8的链表结构是：旧的数据指向新的数据。
（6）.当底层数组的某一个索引位置上的元素以链表形式存在的数据个数大于8 ，且当前数组的长度大于64时，此时这个索引位置上的数据改为使用红黑树存储。

四、HashMap底层重要属性的说明
DEFAULT_INITIAL_CAPACITY：HashMap的默认容量：16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold：扩容的临界值 = 容量 * 填充因子：16 * 0.75 = 12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8
MIN_TREEIFY_CAPACITY：Bucket中Node被转化为红黑树时最小的Hash表容量：64

总结

    存取无序的
        键和值位置都可以是null，但是键位置只能是一个null
        键位置是唯一的，底层的数据结构控制键的
        jdk1.8前数据结构是：链表 + 数组  jdk1.8之后是 ： 链表 + 数组  + 红黑树
        阈值(边界值) > 8 并且数组长度大于64，才将链表转换为红黑树，变为红黑树的目的是为了高效的查询。
        当数据的元素个数达到  初始容量* 加载因子 = 12 的时候才会去扩容

 如何解决冲突
   put()
            put方法是比较复杂的，实现步骤大致如下：
            1）先通过hash值计算出key映射到哪个桶；
            2）如果桶上没有碰撞冲突，则直接插入；
            3）如果出现碰撞冲突了，则需要处理冲突：
            ​    a:如果该桶使用红黑树处理冲突，则调用红黑树的方法插入数据；
            ​    b:否则采用传统的链式方法插入。如果链的长度达到临界值，则把链转变为红黑树；
            4）如果桶中存在重复的键，则为该键替换新值value；
            5）如果size大于（阈值threshold），则进行扩容；