JDK HashMap的实现原理分析

JDK HashMap的实现原理分析

HashMap的数据结构

先来看看数组和链表数据结构的特点：

数组：存储区间连续，寻址容易，插入和删除困难

链表：存储区间离散，寻址困难，插入和删除简单

HashMap的出现就是将数组和链表的优点相结合。

我们发现哈希表是由数组+链表组成的。

一些重要的属性

    //最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;

    //可以看到，是存放Entry<k,v>元素的数组，名为table。
    transient Entry<K,V>[] table;

    //当table的占用超过这个值，就要扩容。
    int threshold;

    //负载因子  threshold = capacity*loadFactory
    final float loadFactor;

数组的存储规则

那么如何确定数据存储在数组的哪个下标中呢？

一般根据 hash(key)&(len-1)来获得，如，数组长度为16，hash(key.hashCode())为2。我们做如下运算：

&:按位与操作，若对应的二进制位都为1，结果为1.

2 & （16-1）

2的二进制为： 0000 0010
15的二进制:   0000 1111
结果：        0000 0010 (转换成int值为2)

最后，该元素就存放在table[2]位置上。

HashMap的基础存储结构

HashMap中有个静态内部类Entry，其属性有key，value，next，hash。key是键，value是值，next是指向下一个Entry元素的引用，hash是key.hashCode()的hash值。如下：

    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        final int hash;
    }

HashMap的存取实现

table初始大小

table的初始大小需要根据HashMap的构造函数来决定。

空参数构造函数

    /**
     * Constructs an empty <tt>HashMap</tt> with the default initial capacity
     * (16) and the default load factor (0.75).
     */
    public HashMap() {
        //负载因子
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        //阈值 当table的占用超过此值时就会扩容
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        //给table的默认长度
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

英文注释已经说明了一切，table的默认长度为16，负载因子的默认值为0.75

当然也可以看看这些常亮的值，如下：

    static final float DEFAULT_LOAD_FACTOR = 0.75f;
     static final int DEFAULT_INITIAL_CAPACITY = 16;

指定容量的构造函数

当然可以直接指定初始容量，其负载因子为默认的0.75

    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

指定容量和负载因子的构造函数

创建HashMap的时候可以指定容量和负载因子，但是HashMap真正的容量并不等于你指定的值。

看下面这段代码，设置capacity的值为1，当其

  public HashMap(int initialCapacity, float 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();
    }

确定数组Index

数组下标 = hash(key.hashCode())&（数组长度-1）

所以，数组下标相同，hashcode不一定相同。

   /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

存取示例代码

简单实现

// 存储时:
int hash = key.hashCode(); // 计算key的hashcode的hash值
//将计算出来的hash与数组长度取余
int index = hash & (Entry[].length-1);
//将值赋予数组下表
Entry[index] = value;

// 取值时:
int hash = key.hashCode();
int index = hash &( Entry[].length - 1 );
return Entry[index];

put的具体实现

put往HashMap中存值

 public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value); //null总是放在table下标为0的链表中

        //计算key的hashCode的hash值
        int hash = hash(key.hashCode());

        //计算要存放的数组下标
        int i = indexFor(hash, table.length);

        //遍历链表
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //如果key在链表中已存在，则替换为新value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                //返回旧值
                return oldValue;
            }
        }

        //遍历链表完毕没有相同的key，则添加值到链表中
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

我们知道，如果在HashMap中，如果当前key已经存在，再put进去相同key的值，就会替换掉旧值。那么这个是如何实现的呢？
主要是下面这段代码:

 if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

如果key的hash相等，且==或者equals对比的值相等，则证明key相等。
我们举个例子：

        String str1 = new String("HelloJava");
        String str2 = new String("HelloJava");
        System.out.println("str1 == str2:"+(str1 == str2));
        System.out.println("str1.equals(str2):"+str1.equals(str2));

        System.out.println("str1的hashcode:"+str1.hashCode());
        System.out.println("str2的hashcode:"+str2.hashCode());

        System.out.println("str1的Hash值："+hash(str1.hashCode()));
        System.out.println("str2的Hash值："+hash(str2.hashCode()));

        //输出结果如下：
        //str1 == str2:false
        //str1.equals(str2):true
        //str1的hashcode:-1094607372
        //str2的hashcode:-1094607372
        //str1的Hash值：-1269085867
        //str2的Hash值：-1269085867

可以看到，str1的hash和str2的hash是相等的，虽然==的值为false，但是equals的值为true，所以str1和str2在HashMap中依然是相等的key.

那么如果判断当前的HashMap中没有此key，就要将其key和value都添加到HashMap中，见下面这个方法:

    void addEntry(int hash, K key, V value, int bucketIndex) {

        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }

可以看到，这个方法其实就是将table[bucketIndex]下的链断开，将新的Entry插入到最前面，再将链搭起来。如下图：

除了这个还有reSize()方法，就是当tale的占用超过threshold时，table长度就会扩充两倍，具体细节下面说。

get的实现

get的实现还是依靠判断key是否相等来取值，若有，则返回其值，若没有则返回null.

public V get(Object key) {
        //如果key等于null，则直接放table数组下标为0的位置上
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        //先定位table数组下标位置，再遍历该位置处的链表
        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;
        }

        //没有找到，返回null
        return null;
}

null值的存取

null key总是存放在table数组的第一个元素位置，也就是table[0]。
注意：0下标不一定只存储key为null的元素

    //存值：
    private V putForNullKey(V value) {
        //将数组下标为0的元素赋值给e,然后遍历这个链表
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {

            //判断null为key的entry是否存在，若存在，替换值，返回旧值
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        //若不存在，添加至链表，返回null
        modCount++;
        addEntry(0, null, value, 0);
        return null;
    }


    //取值
    private V getForNullKey() {
        //判断数组下标为0的链表中，key为null的值是否存在，若存在返回其值
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        //若不存在，返回null
        return null;
    }

解决Hash冲突的方法

现在不予考虑细节

1. 开放定址法（线性探测再散列，二次探测再散列，伪随机探测再散列）
2. 再哈希法
3. 链地址法
4. 建立一个公共溢出区

Java中hashmap的解决办法就是采用的链地址法。

用链地址法处理冲突的办法是：把具有相同散列地址的关键字(同义词)值放在同一个单链表中，称为同义词链表。

再散列reSize的过程

首先这个过程是自动的，当table的占用超过threshold（capticy*loadFactor）时，resize()方法就会自动调用，扩充table的长度。

如果当前的capacity超过了MAXIMUM_CAPACITY，就将threshold设置为Interger.MAX_VALUE，然后就不会扩容了。

具体实现看下面的源码：

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30; //2的30次方

/**
     * Rehashes the contents of this map into a new array with a
     * larger capacity.  This method is called automatically when the
     * number of keys in this map reaches its threshold.
     *
     * If current capacity is MAXIMUM_CAPACITY, this method does not
     * resize the map, but sets threshold to Integer.MAX_VALUE.
     * This has the effect of preventing future calls.
     *
     * @param newCapacity the new capacity, MUST be a power of two;
     *        must be greater than current capacity unless current
     *        capacity is MAXIMUM_CAPACITY (in which case value
     *        is irrelevant).
     */
    void resize(int newCapacity) {
        //旧table
        Entry[] oldTable = table;
        //旧table的容量
        int oldCapacity = oldTable.length;
        //如果旧table的容量==MAXIMUM_CAPACITY，将threshold设置为Integer.MAX_VALUE，返回
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
        //按新容量大小创建newTable
        Entry[] newTable = new Entry[newCapacity];
        //数据转移
        transfer(newTable);
        table = newTable;
        //threshold重新赋值
        threshold = (int)(newCapacity * loadFactor);
    }




 /**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        //遍历原table
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    //将原table的entry重新计算index，再放入到新table中
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }
      .