HashMap常问面试题整理

去面试时，hashmap总是被经常问的问题，下面总结了几道关于hashmap的问题。

1、hashmap的主要参数都有哪些？

2、hashmap的数据结构是什么样子的？自己如何实现一个hashmap？

3、hash计算规则是什么？

4、说说hashmap的存取过程？

5、说说hashmap如何处理碰撞的，或者说说它的扩容？

解答：以1.7为例，也会掺杂一些1.8的不同点。

1、

1）桶（capacity）容量，即数组长度：DEFAULT_INITIAL_CAPACITY=1<<4；默认值为16

　　即在不提供有参构造的时候，声明的hashmap的桶容量；

2）MAXIMUM_CAPACITY = 1 << 30;

　　极限容量，表示hashmap能承受的最大桶容量为2的30次方，超过这个容量将不再扩容，让hash碰撞起来吧！

3）static final float DEFAULT_LOAD_FACTOR = 0.75f;

　　负载因子（loadfactor，默认0.75），负载因子有个奇特的效果，表示当当前容量大于（size/）时，将进行hashmap的扩容，扩容一般为扩容为原来的两倍。

4）int threshold;阈值

　　阈值算法为capacity*loadfactory，大致当map中entry数量大于此阈值时进行扩容（1.8）

5）transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;（默认为空{}）

　　核心的数据结构，即所谓的数组+链表的部分。

2、hashmap的数据结构是什么样子的？自己如何实现一个hashmap？

　　主要数据结构即为数组+链表。

　　在hashmap中的主要表现形式为一个table，类型为Entry<K,V>[] table

　　首先是一个Entry型的数组，Entry为hashmap的内部类：

　　

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

　　在这里可以看到，在Entry类中存在next，所以，它又是链表的形式。

　　这就是hashmap的主要数据结构。

3、hash的计算规则，这又要看源码了：

　　

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

　　这是1.8的源码，1.7太复杂但原理是一致的，简单说这就是个“扰动函数”，最终的目的是让散列分布地更加均匀。

　　算法就是拿存储key的hashcode值先右移16位，再与hashcode值进行亦或操作，即不求进位只求按位相加的值：盗图：

　　

　　最后是如何获得，本key在table中的位置呢？本身应该是取得了hash进行磨除取余运算，但是，源码：

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

　　为什么又做了个与运算求得位置呢？简单说，它的意义和取余一致。

　　不信可以自己算一下。

　　首先说，他利用了table的长度肯定是2的整数次幂的原理，假设当前length为16，2的4次方

　　而与&运算，又是只求进位运算，比如1111&110001结果为000001

　　只求进位运算（&），保证算出的结果一定在table的length之内，最大为1111。

　　故而，它的运算结果与价值等同于取余运算，并且即使不管hash值有多大都可以算出结果，并且在length之内。

　　并且，这种类型的运算，能够更加的节约计算机资源，少了加（计算机所有运算都是加运行）运算过程，更加地节省资源。

4、hashmap的存取过程

　　源码1.7：

/**
*往hashmap中放数据
*/
public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);//判断如果为空table，先对table进行构造
            //构造通过前面的几个参数
        }
        //首先判断key是否为null，为null也可以存
        //这里需要记住，null的key一定放在table的0号位置
        if (key == null)
            return putForNullKey(value);
        //算出key的hash值
        int hash = hash(key);
        //根据hash值算出在table中的位置
        int i = indexFor(hash, table.length);
        //放入KV，遍历链表,如果位置上存在相同key，进行替换value为新的，且将替换的旧的value返回
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        //增加一个entry，有两种情况，1、如果此位置存在entry，将此位置变为插入的entry，且将插入entry的next节点变为原来的entry；2、如果此位置不存在entry则直接插入新的entry
        addEntry(hash, key, value, i);
        return null;
    }

取数据：

//根据key获得一个entry
public V get(Object key) {
        //如果key为null，获取0号位的切key为null的值
        if (key == null)
            return getForNullKey();
        //如果不是，获取entry，在下面方法
        Entry<K,V> entry = getEntry(key);
        //合法性判断
        return null == entry ? null : entry.getValue();
    }
//获取一个key不为null的entry
final Entry<K,V> getEntry(Object key) {
        //如果table为null，则返回null
        if (size == 0) {
            return null;
        }
        //计算hash值
        int hash = (key == null) ? 0 : hash(key);
        //根据hash值获得table的下标，遍历链表，寻找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;
    }

 5.扩容和碰撞

　　先说碰撞吧，由于hashmap在存值的时候并不是直接使用的key的hashcode，而是通过扰动函数算出了一个新的hash值，这个计算出的hash值可以明显的减少碰撞。

　　还有一种解决碰撞的方式就是扩容，扩容其实很好理解，就是将原来桶的容量扩为原来的两倍。这样争取散列的均匀，比如：

　　原来桶的长度为16,hash值为1和17的entry将会都在桶的0号位上，这样就出现了碰撞，而当桶扩容为原来的2倍时，hash值为1和17的entry分别在1和17号位上，整号岔开了碰撞。

　　下面说说何时扩容，扩容都做了什么。

　　1.7中，在put元素的过程中，判断table不为空、切新增的元素的key不与原来的重合之后，进行新增一个entry的逻辑。

void addEntry(int hash, K key, V value, int bucketIndex) {
        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);
    }

　　由源代码可知，在新增元素时，会先判断：

　　1）当前的entry数量是否大于或者等于阈值（loadfactory*capacity）；

　　2）判断当前table的位置是否存在entry。

　　经上两个条件联合判定，才会进行数组的扩容工作，最后扩容完成才会去创建新的entry。

　　而扩容的方法即为：resize（）看代码

　　

void resize(int newCapacity) {
        //拿到原table对象
        Entry[] oldTable = table;
        //计算原table的桶长度
        int oldCapacity = oldTable.length;
        //先判定，当前容量是否已经是最大容量了（2的30次方）
        if (oldCapacity == MAXIMUM_CAPACITY) {
            //假如达到了，将阈值设为int的最大值2的31次方减1，返回
            threshold = Integer.MAX_VALUE;
            return;
        }
        //创建新的table对象
        Entry[] newTable = new Entry[newCapacity];
        //将旧的table放入新的table中
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        //赋值新table
        table = newTable;
        //计算新的阈值
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }
//具体的扩容过程
void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        //遍历原table，重新散列
        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;
            }
        }
    }

至此，扩容就说完了。。。