Java HashMap源码笔记(jdk1.6)

HashMap是一种用于保存键值对（key-value）的数据结构，非线程安全（所有方法都不是同步的），且键和值可以为null（这一点区别于Hashtable）；它的底层数据结构用的是数组（Entry[]） + 链表形式，每一个元素都是一个Entry，每一个Entry都保存着下一个元素的指针（next）。

1：类声明

public class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Cloneable, Serializable

HashMap继承自AbstractMap，并实现了Map接口、Cloneable接口和Serializable接口

2：主要的类变量和实例变量

static final int DEFAULT_INITIAL_CAPACITY = 16;   // 默认容量，即Entry[]数组的默认长度

static final int MAXIMUM_CAPACITY = 1 << 30;    // Entry[]数组的最大长度，即2的30次方；该静态变量的值限制了HashMap初始化或者扩容的时候，Entry[]数组长度不能超过该值。

static final float DEFAULT_LOAD_FACTOR = 0.75f;    // 默认增长因子；

transient Entry[] table;    // 哈希桶，当元素被添加到HashMap的时候，会根据被添加的元素的key值对应的hashcode以及HashMap内的static int hash(int h)方法算出key值对应的hash，然后拿着hash与Entry[]数组的长度取模得到该元素所在的数组下标

transient int size;    // HashMap中的元素个数

int threshold;    // HashMap中元素个数的阈值（当元素个数>=该值，且当前的容量小于MAXIMUM_CAPACITY 时，HashMap会进行扩容，按照当前容量的2倍扩容）

final float loadFactor;    //  增长因子（threshold = 容量（Entry数组长度） * loadFactor）

transient volatile int modCount;    // HashMap结构被修改次数（结构被修改指的HashMap元素个数发生变化的操作，如put一个不存在的元素、删除一个存在的元素；其中调用clear方法时，不管有没有改变元素个数，modCount都会+1），其中volatile关键字表明了该字段被某个线程修改后立刻对所有线程可见（具体可以了解volatile关键字）

3：构造函数

public HashMap(int initialCapacity, float loadFactor)    // 使用指定的容量和增长因子构造一个HashMap，如果initialCapacity不是2的倍数，那么该构造函数会计算出一个刚好大于initialCapacity，且为2的倍数的数字作为初始化容量，比如initialCapacity传递的值是3，那么4将作为HashMap的初始容量；使用容量 * 增长因子算出扩容阈值threshold；接着初始化Entry[]的长度；代码如下：

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)(capacity * loadFactor);
        table = new Entry[capacity];
        init();

4：重要函数

static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

该函数是一个hash方法，根据key值对应的哈希码计算出哈希值；

static int indexFor(int h, int length) {
        return h & (length-1);
    }

该方根据给定的哈希码（上一步中计算结果）以及Entry[]数组的长度，计算出该哈希码所应该在的数组下标；

其中用h & (length-1)求出哈希码对应的数组下标而不用h % length，是因为&的效率比%效率要高；但是如果length不为2的倍数的时候会导致分配不均匀（假设length是7，那么h & (7 - 1)的结果永远都是偶数，这样取到的数组下标就永远都是偶数，相当于浪费了奇数下标的数组），而当length为2的倍数的时候刚好就等同于  h % length，所以HashMap的容量规定为2的倍数就是为了能够更加均匀

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode()); // 调用hash方法计算出key对应的哈希码
        for (Entry<K,V> e = table[indexFor(hash, table.length)]; // 根据哈希码以及table的长度计算出数组下标，得到该下标里面的Entry链表，
             e != null;  // 并从链表头开始一直往后遍历，直到遍历到的entry的哈希码跟key的哈希码相等并且entry的key == 参数中的key或者equals
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null; // 如果都没有找到则返回null
    }

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode()); // 调用hash方法计算出key对应的哈希码
        int i = indexFor(hash, table.length); // 根据哈希码找到对应的数组下标i
        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))) { // 如果遍历到的entry的哈希码跟参数中key的哈希码相等，并且entry的key == 参数key或者equals，那么证明原先的HashMap中存在同样的key
                V oldValue = e.value; // 获取原有key对应的value
                e.value = value; // 将原有key对应的value替换成新的value
                e.recordAccess(this);
                return oldValue; // 返回原有key对应的value
            }
        }

        modCount++;
        addEntry(hash, key, value, i); // 如果key值不存在于HashMap中，则调用addEntry方法，往HashMap中添加一个元素;i为目标数组下标
        return null;
    }

void addEntry(int hash, K key, V value, int bucketIndex) { // 往HashMap中指定的数组下标添加一个键值对，添加在链表头部（这样只需要将新元素的next指针指向原有头部就可以了）
	Entry<K,V> e = table[bucketIndex]; // 获取原有链表的头部
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e); // 构造新的entry，并将原有链表头部设置成新entry的下一个元素
        if (size++ >= threshold) // 如果添加之后总元素个数大于阈值，则扩容为原有数组长度的两倍
            resize(2 * table.length); 
    }

void resize(int newCapacity) { // HashMap扩容
        Entry[] oldTable = table; // 先将原有的数组赋值给一个临时变量oldTable
        int oldCapacity = oldTable.length; // 获得原有容量
        if (oldCapacity == MAXIMUM_CAPACITY) { // 如果原有容量等于最大容量，则不在进行扩容
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity]; // 声明一个长度为newCapacity的Entry[]数组
        transfer(newTable); // 将原有数组里面的元素赋值到新数组
        table = newTable; // 将新数组赋值给HashMap的实例变量table
        threshold = (int)(newCapacity * loadFactor); // 重新计算阈值
    }