HashMap源码分析

一、什么是哈希表

1.定义

哈希表（hash table、散列表），是一种常用的数据结构。通过数组+链表实现，数组我们称为hash数组。 我们要新增或查找某个元素，我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置。 其中，这个函数f一般称为哈希函数，这个函数的设计好坏会直接影响到哈希表的优劣。hash函数的种类有多种，HashMap种采用的直接寻址方式。
举例：有两个元素A、B想要加入哈希表，过程如下

2.地址冲突

那么问题来了，如果有元素F也想加入hash表，但是算出的地址也是2，和B是同一个地址，怎么办？
HashMap是采用链地址法进行解决的，将同一地址的元素存储在同一线性表中，后插入的在链首。

3.效率问题

如果不考虑地址冲突问题， 在哈希表中进行添加，删除，查找等操作，性能十分之高， 时间复杂度为O(1)。由此可见，hash性能的瓶颈为地址冲突问题。

如果hash数组长度为n，那么应该存放几个元素最为合适，地址冲突率最低？在HashMap中通过变量initialCapacity设置hash数组的初始长度，loadFactor设置加载因子（即数组的填充率）。
initialCapacity*loadFactor即为实际存放的元素。

若加载因子越大，则产生冲突的可能就会越高（效率低），但空间利用率更高。
若加载因子越小，则产生冲突的可能性会越低（效率高），但空间利用率更低。
这就是传说中的时间与空间的问题。

HashMap要求hash数组的长度必须是2的倍数，求位置的方式为【h & (length-1)】，h为hash码，length为hash数组长度，当数组长度不够时，需要扩容，扩容后的hash数组长度为原数组的2倍。为什么要这样设计？？？
假设h=10，length=16（二进制10000），length-1=15（二进制1111）
扩容后，h=10，length=32（二进制100000），length-1=31（二进制11111）
我们来看下，扩容和不扩容情况下，计算的情况

①不扩容

②扩容

我们发现，扩容后的计算的位置和没扩容之前计算的位置相同，都是10，就能保证得到的新的数组索引和老数组位置一致(大大减少了之前已经散列良好的老数组的数据位置重新调换)。
如果length不是2的倍数，也就是低位不全是1，将会有两种可能同时计算得到位置10，导致冲突增加。

4.源码分析
4.1 关键属性

/**默认初始容量16，必须是2的倍数**/
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**最大初始容量**/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**默认加载因子**/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**hash数组，采用链表法解决冲突，每一个Entry本质上是一个单向链表**/
transient Entry<K,V>[] table;
/**数组大小**/
transient int size
/**实际填充大小**/
int threshold;
/**实际加载因子大小**/
final float loadFactor

4.2 构造函数

public HashMap();
public HashMap( int initialCapacity );
public HashMap ( int initialCapacity, float loadFactor );
public HashMap(Map<? extends K, ? extends V> m );

看第三个构造函数

  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;
        //找出“大于initialCapacity”的最小的2的幂 
        while (capacity < initialCapacity )
            capacity <<= 1;

        this.loadFactor = loadFactor ;
        threshold = (int )Math.min( capacity * loadFactor , MAXIMUM_CAPACITY + 1);
        //创建Entry数组，用来保存数据
        table = new Entry[capacity ];
        useAltHashing = sun.misc.VM.isBooted() &&
                ( capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD );
        //init方法在HashMap中没有实际实现，不过在其子类如 linkedHashMap中就会有对应实现
        init();
    }

Entry是HashMap中的一个静态内部类。代码如下

static class Entry <K,V> implements Map.Entry<K,V> {
        final K key ;
        V value;
        //存储指向下一个Entry的引用，单链表结构
        Entry <K,V> next ;
        //对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算
        int hash ;

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

所以HashMap的结构如下：

简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度依然为O(1)，因为最新的Entry会插入链表头部，急需要简单改变引用链即可，而对于查找操作来讲，此时就需要遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。

4.3 put方法源码

public V put (K key , V value ) {
        if (key == null)
            return putForNullKey(value );
        //通过key获取hash值
        int hash = hash(key );
        //根据hash值获取在hash数组中对应的位置
        int i = indexFor( hash, table. length);
        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 ;
            }
        }

        modCount++;
        addEntry( hash, key, value, i);
        return null ;
    }

我们知道，HashMap可以添加key为null的键值对，具体看下putForNullKey()方法

private V putForNullKey (V value ) {
        for (Entry<K,V> e = table [0]; e != null; e = e .next ) {
            if (e .key == null) {
                V oldValue = e. value;
                e. value = value;
                e.recordAccess( this );
                return oldValue ;
            }
        }
        //修改次数加1
        modCount++;
        //如果没有key为Null的值，则加入hash数组
        addEntry(0, null , value , 0);
        return null ;
    }

会覆盖掉之前key为null的值，返回value。如果hash数组中没有key为null的值，则加入hash数组。

void addEntry( int hash , K key , V value , int bucketIndex) {
        //如果hash数组容量不够，则需要扩容
        if ((size >= threshold ) && ( null != table [bucketIndex ])) {
            //hash数组长度增加一倍
            resize(2 * table. length);
            hash = ( null != key ) ? hash( key) : 0;
            bucketIndex = indexFor( hash, table. length);
        }

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

void createEntry( int hash, K key, V value, int bucketIndex ) {
        //如果hash数组bucketIndex有值，则next属性指向它，否则next为null
        Entry<K,V> e = table[ bucketIndex ];
        //hasn数组中的元素都是链表的头
        table[ bucketIndex ] = new Entry<>( hash, key, value , e );
        size++;
    }

4.4 扩容函数，数组转换函数

//对数组进行扩容
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 ];
        boolean oldAltHashing = useAltHashing ;
        useAltHashing |= sun.misc.VM.isBooted() &&
                ( newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD );
        boolean rehash = oldAltHashing ^ useAltHashing ;
        transfer( newTable, rehash);
        table = newTable;
        threshold = (int )Math.min( newCapacity * loadFactor , MAXIMUM_CAPACITY + 1);
    }


//拷贝旧的键值对到新的哈希表中
void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable .length ;
        for (Entry<K,V> e : table ) {
            while (null != e ) {
                Entry<K,V> next = e. next;
                if (rehash ) {
                    e. hash = null == e .key ? 0 : hash(e .key );
                }
                int i = indexFor( e. hash, newCapacity );
                e. next = newTable[ i];
                newTable[ i] = e;
                e = next;
            }
        }
    }

对于数组转换函数需要详细说下，for循环用来遍历hash数组，while是用来遍历链表。分析下while循环，
①记录下一个节点的位置，如果不记录可能就找不到后面的节点了。
②计算在新hash数值中对应的位置【int i = indexFor( e. hash, newCapacity )】
③对于newTable[i]，可能有值，可能没值，但是e要放到链首，e.next指向原来的newTable[i]
④newTable[i]指向新的位置e
⑤下一个循环的节点e.next

例如遍历到oldTable[1]为头的单链表的 【entryD引用】 节点，具体过程如下：

4.5 get函数

public V get(Object key) {
        if (key == null)
            return getForNullKey();
        //根据key获取Entry
        Entry<K,V> entry = getEntry( key);

        return null == entry ? null : entry.getValue();
    }

下面来看根据根据key获取Entry

final Entry<K,V> getEntry(Object key ) {
        int hash = (key == null) ? 0 : hash( key);
        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 != null && key .equals(k ))))
                return e ;
        }
        return null ;
    }

没啥东西。