ArrayList HashMap源码分析

Java集合总结

1、java集合概述
为了方便多个对象存储，使用数组存储对象会有一些弊端，需要动态的把多个对象的引用放入到容器中，所以才产生了集合。数组的弊端由，初始化后长度就确定了，不便于拓展，提供的属性和方法都很少，不便于添加、删除、插入等操作，数组存储的特点十分的单一。
集合的脉络图如下图所示：

2、常见的ArrayList、LinkedList、Vector三者的异同
同：都实现了List接口，存储有序、可重复的数据，底层都是动态数组
不同：ArrayList 为主要的实现类，线程不安全、效率高 底层使用Object数组
Vector 作为List接口古老实现类，线程安全，效率低 底层使用Object数组
LinkedList 底层使用的双向链表，对于频繁的插入删除操作，比ArrayList高
源码分析：
ArrayList源码分析
jdk7时候：当创建的是空集合，空参造一个长度为10的数组

List list = new ArrayList();

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this(10);
    }

list.add("123");

list.add(11); 如果此次添加导致底层elementData数组容量不够，则扩容
默认情况下，扩容是原来容量的1.5倍，同时将原有数组复制到新的数组中
底层是

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

在jdk8中，只有当第一次调用的时候，才创建长度为10的数组，并将要添加的添加到element中，其他无异。
小结：jdk8中的方式更加节省内存，符合懒汉式的想法，只有调用时，才会创建。
LinkedList源码分析

List list = new 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;
        }
    }

node体现的是双向链表的说法，内部声明了next、prev的属性，其默认为null 1.7、1.8无异
Vector源码分析：

    /**
     * Constructs an empty vector so that its internal data array
     * has size {@code 10} and its standard capacity increment is
     * zero.
     */
    public Vector() {
        this(10);
    }

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

Vector1.7、1.8并没有任何改变，就是初始化一个长度为10的数组，每次扩容到2倍
3、Set的源码分析
Set是存储无序、不可重复的数据，类似于高中讲的集合。
Set
HashSet：作为Set接口的主要实现类，线程不安全，可以存储null
LinkedHashSet: 作为HashSet的子类，底层维护着链表，可以按照添加到顺序
TreeSet: 底层是红黑树 可以按照添加指定的属性，进行排序
Set的底层是其实是Map，所以分析Map即可。
4、Map的源码分析
Map：双列数据，存储key-value对的数据，类似于高中的函数y=f(x)
HashMap:Map的主要实现类 1.2时候有的，线程不安全，效率高，可以存储key,value为null的
LinkedHashMap:在原有的HashMap底层基础上，添加了一对指针，指向前一个跟后一个指针频繁的遍历效果好
TreeMap:可以按照添加的key-value对进行排序，实现排序遍历 考虑key的实现底层使用的红黑树
Hashtable:作为古老的 1.0 线程安全、效率低 不能存储null的key和value
Properties 常用来处理配置文件 key和value都是String类型
HashMap1.7源码分析

HashMap map = new HashMap();

    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

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

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        init();
    

底层创建一个Entry的一维数组其长度是16

map.put(key,value);

首先，计算key1的hashCode()计算key1哈希值，经过某种算法计算以后，得到Entry数组中存放位置
如果位置上的数据为空，此时的key1-value1添加成功 情况1
如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据），比较key1和存在的哈希值
如果都不相同，此时key1-value1添加成功 情况2
如果key1的哈希值相同，继续比较：调用key1所在类的equals()方法，比较：
如果equals()返回false:此时key1-value1添加成功 情况3
如果equals()放回true:使用value1替换相同key的value值
补充：关于情况2和情况3：
关于情况2和情况3，此时key-value1和原来的数据以链表的方式存储
不断的添加过程中，当超出临界值时并且要存放的位置非空时候 会涉及到扩容问题，默认的扩容方式：扩容到原来的2倍，并且将原有的数据复制过来

 public V put(K key, V value) {
        //HashMap允许存放null键和null值
        //当key为null时，调用putForNullKey方法，将value放在第一个位置
        if (key == null)
            return putForNullKey(value);
        //根据key重新计算hash值    
        int hash = hash(key);
        //搜索指定hash值对应table中的索引
        int i = indexFor(hash, table.length);
        //如果部位null，则继续遍历下一个元素
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        //如果为null,则表明此处没有Entry
        modCount++;
        //将key、value添加到i索引处
        addEntry(hash, key, value, i);
        return null;
    }
   //从上面源码可以看出，如果位置没有的话，就会添加，有的话，就会以链表的形式存在，最先加入的在链表尾，最后加入的在链表头
    /**
     * Adds a new entry with the specified key, value and hash code to
     * the specified bucket.  It is the responsibility of this
     * method to resize the table if appropriate.
     *
     * Subclass overrides this to alter the behavior of put method.
     */
    void addEntry(int hash, K key, V value, int bucketIndex) {
        //扩容的条件是大于临界值并且要插入的值不在其他已经有的位置，是一个空的位置
        if ((size >= threshold) && (null != table[bucketIndex])) {
            //将table对象扩容到原先的2倍
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            //重新开始计算索引值
            bucketIndex = indexFor(hash, table.length);
        }
        createEntry(hash, key, value, bucketIndex);
    }

        /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }
    存位，而 HashMap底层数组的长度总是 2 的 n 次方，这是 HashMap 在速度上的优化

HashMap1.8源码分析
jdk 8底层数组是：Node[]，并非Entry[]
首次调用Put方法时候，底层创建长度为16的数组
jdk底层结构只有：数组+链表 jdk8 数组+链表+红黑树
当数组的某一个位置的元素以链表存在个数>8并且当前数组的长度>64时
此时索引位置上的所有数据改成红黑树存储

    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
     //首次并没有创建，只要当put方法是时候才会创建
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

     final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //如果hash表为空，则创建一个哈希表
        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;
    }
  
      final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        //计算扩容的大小
        if (oldCap > 0) {
            //如果当前容量超过最大容量，则无法进行扩容
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //没超过的最大值扩为原来的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        //新的resize阈值
        threshold = newThr;
        //创建新的哈希表
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

总结：
JDK1.8HashMap是通过红黑树+哈希表结合使用，按照原来的拉链表解决冲突，如果一个桶上的冲突很严重的话，会导致哈希表的效率降至O(n),通过红黑树，可以把效率改进至O(logn)。相比链式结构的节点，树形结构节点比较多的空间，这个是空间换时间的改进方式。