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