Java中HashMap源码浅析

在Java编码中可以说HashMap的使用是可以说是无处不在的，对于HashMap的实现原理没有去过多深入学习，一直停留在使用阶段。现在想来还是要一探HashMap的实现原理，不要一味的只是停留在使用阶段。而且HashMap的原理在很多面试中都会问到哦，所以弄清楚还是很有必要滴。

先来看看HashMap的构造函数，一共提供了4中
HashMap(Map m)指定 Map 相同的新 HashMap
HashMap(int initialCapacity, float loadFactor)//指定初始容量，构造因子
HashMap(int initialCapacity)//指定初始容量，构造因子是默认的0.75
HashMap()//初始容量是16，构造因子默认是0.75

下面在分别来看里面几个最常用的方法put（k，v）

 public V put(K key, V value) {
        //如果table数组为空，就创建table数组
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        //hashmap是支持null值的
        if (key == null)
            return putForNullKey(value);
        //计算出key的hash值
        int hash = hash(key);
        得到在table数组中的下标
        int i = indexFor(hash, table.length);
        //通过这块可以看出HashMap的存储结构是数组+链表
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //如果元素hash值相同&&key值也相同，新put的value覆盖oldvalue
            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添加
        addEntry(hash, key, value, i);
        return null;
    }

这上面就是put（k,v）存储键值对的流程，这里面的键值对，是通过Entry来存放，一个Entry对应一个键值对。
Entry有key，value，next，hash这几个属性

 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next; //为了解决哈希冲突
        int hash;
 }

现在我们可以大致的画出HashMap中元素存储的方式

就是table数组+链表，后面的链表是为了解决hash冲突.

//计算出每一个键值对Entry在table数组的下标值。
//这里的注释写明数组的长度必须是2的幂次方，这里写明为什么是2的幂次方？
static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }

上面indexfor中length参数指明要2的幂次方，这里说点我的理解。通过indexfor就算出的bucketid必须是要尽可能少的出现冲突，2^n-1用二进制表示的话都是111111……11串，这样去与hash值进行与运算的话，出现的冲突是最小的，因为如果去与含有0的二进制串与，必定会出现数组中有的下标肯定不会用到. 这里肯定会想如果只是进行低位的运算，那hash值高位没有参与运算。这个其实是在hash（）里面得到处理了的。这里获取对象的hash值并不是直接获取对象的hashcode，而是对对象进行二次hash

final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();

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

所以Hashmap即使提供capacity让我们指定参数，真正的hashmap在构造时都将数组的长度设置为2的幂次方

    int capacity = 1;  
    while (capacity < initialCapacity)   
         capacity <<= 1;  

如果key值不相等，添加entry到数组

 void addEntry(int hash, K key, V value, int bucketIndex) {
     //这里的threshold是capacity*loadFactor就是hash表中存储元素的极值。如果大于这个值，hash会扩容
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }

上面说到的是往集合里面去put键值对，同样有存入就会有获取，再来看看get（Object key）如何获取值

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        //通过key获取Entry
        Entry<K,V> entry = getEntry(key);
        //通过Entry获取value
        return null == entry ? null : entry.getValue();
    }

上面的get方法写的简单，主要是通过key获取对应的键值对，再通过Entry获取对应的值

 final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }
        //获取key的hash值
        int hash = (key == null) ? 0 : hash(key);
        //通过hash值找到bucketId,开始遍历table数组中bucketId下标对应的元素的列表
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            //如果hash值相同，并且key值也相同，返回Entry
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

上面对HashMap的存值和取值有了个初步的认识。
我们知道HashMap是支持null值null键的，下面就来看看null值是怎样存储的^-^

 private V putForNullKey(V value) {
        //在调用这个方法之前，会判断key是否为null，为null就执行这个方法了。
        //从这里可以看出key为null的的entry是存放在table数组的第0个下标中。
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            //如果再存放一个key为null的值，那么把之前的value覆盖掉
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }

我们经常会说HashMap是线程不安全的，但是HashTable是线程安全的。那就从它们代码的实现方式看看HashMap为啥是线程不安全的
下面是HashTable实现存放元素的方法，注意这个方法是加了synchronized的，说明这个方法是线程安全的，而我们上面看的HashMap方法并没有加Synchronized，如果在多线程情况下，同时对HashMap进行put元素时，如果两个元素key值的Hash值相同，这时会有避免Hash冲突，会在table数组的对应节点的链表进行元素插入，如果这个两个元素取到的相同的节点，必定会有一个数据会丢失。

如果当多个线程都检查到需要进行resize，那么会各自生成一个新的数组并rehash后赋给该map底层的数组table，最后只有最后一个线程生成的新数组被赋给table数组，其他线程的均会丢失。如果当某些线程已经完成赋值而其他线程刚开始的时候，就会用已经被赋值的table作为原始数组，从而也会导致问题

//HashTable 中put实现方式
public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry tab[] = table;
        int hash = hash(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                V old = e.value;
                e.value = value;
                return old;
            }
        }

        modCount++;
        if (count >= threshold) {
            // Rehash the table if the threshold is exceeded
            rehash();

            tab = table;
            hash = hash(key);
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        Entry<K,V> e = tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
        return null;
    }