[Java基础]直面HashMap

---

前言

HashMap在平时Android开发中会经常遇到，所以了解了它的原理才能更好地去使用它。

---

概念

1.什么是HashMap

HashMap 是Java中的集合容器，以key-value键值对存储对象，数据结构在1.7以前是数组+链表，在1.8之后是数组+链表+红黑树。

---

问题

1.HashMap原理（1.7）

HashMap底层是通过数组的形式存储数据，每个元素是链表的头节点，其中链表的结点又是一个Entry对象，存储了真正的内容信息，比如key，value,hashcode,next结点。

2.HashMap put的过程

首先HashMap在构造的时候定义了初始容量

//最简单的构造函数，最终都是调用最下面的HashMap(int initialCapacity, float loadFactor)
//DEFAULT_INITIAL_CAPACITY 默认容量  16
//DEFAULT_LOAD_FACTOR 默认加载因子 0.75
 public HashMap() {
     this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
 }

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

  //HashMap构造函数，最终都会调用到这里
  
 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;
     while (capacity < initialCapacity)
         capacity <<= 1;

     this.loadFactor = loadFactor;
     //threshold  扩容阈值 = 容量 * 加载因子
     threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
     table = new Entry[capacity];
     useAltHashing = sun.misc.VM.isBooted() &&
             (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
     //空实现，为了以后其他子类实现用的
     init();
 }

接下来就是put函数的调用，当我们往HashMap中存入数据时，就会执行该方法，也是重点。

	public V put(K key, V value) {
		if(table == EMPTY_TABLE) {
			//如果数组为空，则构造一个容量为16的数组
			inflateTable(threshold);
		}
        if (key == null)
        	//如果key == null，那么就会将这个键值的对象放到数组的第一个，且永远只有一个value,会被覆盖
            return putForNullKey(value);
        //对key进行hash值计算
        int hash = hash(key);
        //为的是得到一个int值，作为数组存放位置的下标
        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;
            }
        }

        modCount++;
        //如果不存在就添加到数组中
        addEntry(hash, key, value, i);
        return null;
    }

如果数组中不存在该节点就会添加到数组中，

	void addEntry(int hash, K key, V value, int bucketIndex) {
		//判断容量是否够
       if ((size >= threshold) && (null != table[bucketIndex])) {
       		//如果超过了阈值，就扩容2倍
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            //重新计算hash,将对应的值存储到下标位置
            bucketIndex = indexFor(hash, table.length);
        }

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

	void createEntry(int hash, K key, V value, int bucketIndex) {
		//保存原先位置的entry
       	Entry<K,V> e = table[bucketIndex];
       	//将新值赋值给bucketIndex位置，同时将该节点的next节点指向之前的Entry，也就是头插法形成链表
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }

3.HashMap中的hash计算是怎么样的，如何得到下标

	final int hash(Object k) {
	    int h = 0;
	    
	   	...
	   	
		//使hash值生成的更加均匀和随机，避免出现hash值冲突
	    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);
	}

这里是h是key的hashcode值，length是数组的长度

	static int indexFor(int h, int length) {
		//进行与运算
        return h & (length-1);
	}

与运算规则：0&0=0；0&1=0；1&0=0；1&1=1 即：两个同时为1，结果为1，否则为0
比如
0011 0010 1101 0100
& 0000 1100 0001 0010
= 0000 0000 0001 0000

这里与运算是为了将hashcode的高位全部归零，只保留低位值，得到的结果也不会大于n - 1，用来做数组下标访问。位运算效率也高，减小cpu资源消耗。

4.HashMap每次扩容为什么是2的指数幂

上面的与运算其实就可以很好解释这个问题，本质是为了加大离散程度。如果是2的指数幂，那么二进制数中肯定有一位是1，如果n-1的话，左边高位就全部归零，右边低位就变成了1。这样进行与运算，就能得到需要的低位值了。
比如拿初始容量16来举例，16-1 = 15， 15的二进制数就变成了0000 0000 0000 1111，这个时候随便一个hash值与运算一下就能得到低位值了。
0000 0000 0000 1111
&
0100 1100 1000 1011
——————————
0000 0000 0000 1011

如果不使用2的指数幂，而是随便一个数，比如我们用14，0000 0000 0000 1110
0000 0000 0000 1110
&
0100 1100 1000 1011
——————————
0000 0000 0000 1010
那么得到的结果是后面低位的最后一位永远是0，这样造成比如0001， 0011，0101等永远也无法生成相应的数组index，会浪费空间，而且增加碰撞的几率，减慢查询效率。

5.为什么HashMap要将key hash一下再存入，而不是直接拿key存

假如不适用key的hashcode存入，直接使用key，那么如果需要索引出所需要的value，就要使用存入value所对应的key，这在实际使用中是很难达到的。

6.为什么HashMap要使用红黑树

当存储的链表长度过长时，那么查询的效率就会很低，当链表长度超过8时，链表就会转为红黑树，查询的效率就会增加。

7.HashMap为什么要用红黑树，而不用二叉树

二叉查找树在特殊情况下会变成一条线性结构（这就跟原来使用链表结构一样了，造成很深的问题），遍历查找会非常慢。

8.HashMap最大的容量是多少

因为使用计算的是int值，而int最大值是2的32次方-1，所以最大容量是2的30次方

9.为什么负载因子是0.75

HashMap是一个数据结构，数据结构需要在时间和空间上做好优化。负载因子的作用是为了在节省时间和空间两者做出最大的优化。
当负载因子为1.0时，每次只能等数组满了才扩容，这个时候会有大量hash冲突，底层的红黑树会变得复杂，查询效率也会降低。
当负载因为为0.5时，每次数组长度为一半就扩容，hash冲突虽然少了，但是底层链表长度或红黑树高度会降低，查询效率也会增加，但是空间就大了，每次一半就扩容，内存的压力就会变大。

所以说当负载因子是0.75的时候，空间利用率比较高，避免了比较多的Hash冲突，底层的链表或者是红黑树的高度比较低，空间效率相对比较高。

10.如何存储有序的HashMap

使用LInkedHashMap存储数据