ArrayList、HashMap、HashSet源码总结

ArrayList：

1. ArrayList是List接口的大小可变数组的实现，此实现是不同步的。
2. ArrayList内部使用类型为Object[]的数组存储元素。
3. ArrayList默认的数组长度为10, 当需要扩大容量时，扩大后的容量为：newCapacity = (oldCapacity * 3)/2 + 1；
4. ArrayList的clone方法为浅拷贝（shallow copy）
5. ArrayList的remove方法根据参数类型的不同有两种重载：
remove(int index) : 删除指定位置的元素；
remove(Object o)  : 删除第一个遇到的元素，如果没有不做改变
6. ArrayList允许null值、允许重复值、不排序，获取快速，增删麻烦。

HashMap：

 HashMap是不同步的。
 HashMap内部使用类型为Entry[]的数组存储元素。Entry是HashMap的一个内部类，定义如下所示。
 每一个Entry对象其实是一个单向链表，之后的解析可以看到，最后存入的元素在最前面。

   备注：下面出现的代码都是HashMap.java中的源码，中文描述是作者加的。

 transient Entry[] table;//HashMap内部定义的数据存储变量
     //内部类
     static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;
        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

       *****
       省略
       *****
    }

 HashMap中几个概念：

 capacity：容量，即Entry[]数组的长度
 loadFactor：负载因子，Entry[]数组中实际数据量/容量的比例达到loadFactor时，HashMap就需要扩大容量了，一般扩大为原来的两倍。
 threshold: 当HashMap中的元素个数超过这个数值时，就将扩大容量。

 put方法：

public V put(K key, V value) {
        if (key == null)
        //如果key为null，特殊处理，key为null直接存储在table[0]位置。
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);//此处得到的i即为key对应的HashMap中的存储位置table[i]
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        //从Entry链表的第一个开始如果找到与key执行equals方法为true的Entry，则修改对应Entry的value值为新值，key不做修改
            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;
            }
        }
        modCount++;
        //如果没有找到对应的key，则执行增加操作
        addEntry(hash, key, value, i);
        return null;
    } 

void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            //如果大小超过了threshold，扩大容量为原来的两倍。扩大容量时，所有的key-value需要重新hash。
            resize(2 * table.length);
}

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }
    Entry[] newTable = new Entry[newCapacity];
    transfer(newTable);//将原来hash表中的数据放入新的hash表中，需要重新hash。
    table = newTable;
    threshold = (int)(newCapacity * loadFactor);
}

/**
 * Transfers all entries from current table to newTable.
 */
void transfer(Entry[] newTable) {
    Entry[] src = table;
    int newCapacity = newTable.length;
    for (int j = 0; j < src.length; j++) {
        Entry<K,V> e = src[j];
        if (e != null) {
            src[j] = null;
            //此处使用循环，将原来hash链中的所有的key-value都重新获取hash值，重新放置。
            //因为放置位置是跟hash表的大小有关的，当hash表容量扩大后，之前放在一个地方的key-value对现在可能hash不到同一个地方了。
            do {
                Entry<K,V> next = e.next;//记录此处的下一个地址
                int i = indexFor(e.hash, newCapacity);//重新计算当前的key-value在新hash表中的位置
                e.next = newTable[i];//将之前在同一位置的数据放在e的next位置，没有则为null
                newTable[i] = e;//将e作为hash表i位置的第一个元素
                e = next;//将next赋值给e， 对原来j位置的所有的元素都执行重新hash，重新放置
            } while (e != null);
        }
    }
}

 get方法：按照put时的逻辑根据key获取value。不再详述。

 keySet与values方法：

这两个方法作用好理解，但需要注意的是，当对keySet()和values()方法获取到的集合执行remove操作的时候就相当于对HashMap集合本身执行remove操作。看源码通过keySet和values获取到的好像是HashMap的迭代器，这里我没有深究。如果谁明白具体原因不吝赐教。

HashSet:

 HashSet的内部是用的HashMap实现的，使用Entry将每一个HashSet元素的引用存储在key位置，value位置使用默认的数据填充。
 在此也可以看到，HashMap中的key-value对其实可以看成value是每一个key的附属，只需要找到每一个key的位置，然后把对应的value放入即可。