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);
         //放入K\V，遍历链表,如果位置上存在相同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;
             }
         }
     }

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