Java集合详解四：HashMap源码详解

  在上一节中，我们讲了HashMap、LinkedHashMap、TreeMap、Hashtable的区别与使用，链接为 Java集合详解三：HashMap、LinkedHashMap、TreeMap、Hashtable的区别与使用 这一节，我们将会从源码角度讲一下HashMap的实现。

  下面以jdk1.6中的HashMap讲解其源码：

一、存储原理

   首先，HashMap中的key-value使用Node来进行存储，而Node之间是怎么进行连接的呢？使用数组+链表的形式进行存储，即哈希表：

  

  哈希表即为头部使用数组进行存储，头部之后的数据使用链表进行存储。

二、源码解析：

  1、存储的节点源码：

 HashMap中的key-value使用Entry类来进行存储，源码如下：

    static class Entry<K,V> implements Map.Entry<K,V> {
	// 保存的key值
        final K key;
	// 保存的value
        V value;
	// 下一个Entry的指针
        Entry<K,V> next;
	// hash值
        final int hash;

	// 构造方法
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

	// 设置value，返回旧的value
        public final V setValue(V newValue) {
	    V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        public final int hashCode() {
            return (key==null   ? 0 : key.hashCode()) ^
                   (value==null ? 0 : value.hashCode());
        }

        public final String toString() {
            return getKey() + "=" + getValue();
        }

	…

       }

2、HashMap的重要参数与构造方法：

HashMap中的关键属性：

// 存储着链表头部的数组
transient Entry[] table;

// map的实际大小
transient int size;

// 临界值，当实际大小超过临界值时，会进行扩容 threshold = 加载因子 * 容量
int threshold;

// 加载因子
final float loadFactor;

// Map被修改的次数
transient volatile int modCount;




    // 有参构造方法：
    // 其中 initialCapacity 为初始化的table的大小
    // 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);

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
	// 注意，此为一个while循环，来保证最后的 capacity 为比initialCapacity大的2的n次方
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
	// init()只为一个空的方法，用来做回调的
        init();
    }

    // 默认的数组大小
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    // 数组最大的数量，2的30次方
    static final int MAXIMUM_CAPACITY = 1 << 30;

    //默认的加载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    // 无参构造方法：
    public HashMap() {
	//可以看到，默认的加载因为为 0.75
        this.loadFactor = DEFAULT_LOAD_FACTOR;
	// 默认的临界值即为 16 * 0.75 = 12
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
	// 默认的table数组为16
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

put(key,value)方法：

put(key, value)方法：
    public V put(K key, V value) {
        if (key == null)
            // 当key为null的时候，会插入一个key为null的entry，当然因为hashMap的key都是唯一的，所以，如果以前有个key为null的entry，会替换其value。
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        // 得到entry在table中的位置
        int i = indexFor(hash, table.length);
        // 此为判断table对应的单链表上有无一样的key，如果有，那么就替换，然后返回原先的值
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 当key值完全相等时，替换
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        // 走到这一步，那么肯定原先table上的单链表没有一样的key，直接调用addEntry添加即可
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

可以看到，hashMap会先得到key的hash值，然后根据hash值得到在自己的数组中的位置，然后遍历对应链表，进行替换或新增

get(Object key)方法：

    public V get(Object key) {
	// 如果为空，得到key为null的entry的value
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
	// 遍历table[indexFor(hash, table.length)]对应的单链表，如果找到entry中key相同的，返回value，否则返回null。
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }