HashMap详细总结

1.实现Map接口

2.HashMap的默认初始值为16

    /**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

3.HashMap的默认最大容量为2^30

    /**
     * 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;

4.负载因子默认为0.75

负载因子=容量/元素总量

    /**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

5.链表和红黑树相互转化的时机

当哈希桶中某条链表长度超过8且桶的个数大于64时，将链表转化为红黑树，否则直接扩容。当红黑树中结点小于6时，又从红黑树转化为链表。

	/**
     * The bin count threshold for using a tree rather than list for a
     * bin.  Bins are converted to trees when adding an element to a
     * bin with at least this many nodes. The value must be greater
     * than 2 and should be at least 8 to mesh with assumptions in
     * tree removal about conversion back to plain bins upon
     * shrinkage.
     */
     //树状阈
    static final int TREEIFY_THRESHOLD = 8;

    /**
     * The bin count threshold for untreeifying a (split) bin during a
     * resize operation. Should be less than TREEIFY_THRESHOLD, and at
     * most 6 to mesh with shrinkage detection under removal.
     */
     //不稳定阈
    static final int UNTREEIFY_THRESHOLD = 6;

    /**
     * The smallest table capacity for which bins may be treeified.
     * (Otherwise the table is resized if too many nodes in a bin.)
     * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
     * between resizing and treeification thresholds.
     */
     //当链表长度超过8，桶的个数超过64时，链表转化为红黑树，否则扩容
    static final int MIN_TREEIFY_CAPACITY = 64;

6.哈希桶的结构

哈希桶中的链表是单链表。

	//HashMap中的结点结构
	/**
     * Basic hash bin node, used for most entries.  (See below for
     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
     */
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;//哈希值
        final K key;//键，不可变
        V value;//值
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

7.哈希函数

key为空时，返回0号桶
key不为空，返回该key所对应的哈希码。
若key为自定义类型，必须重写hashCode方法。

	static final int hash(Object key) {
	        int h;
	       //将key的hashcode与key的hashcode右移16位的结果按位异或
	       /**主要用于当hashmap 数组比较小的时候所有bit都参与运算了
目的是减少碰撞*/
	        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        }

获取哈希地址后，计算桶号的方式为：index = (table.length-1)&hash

  	/**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
            
            //桶号的获取方式：
            //index = (table.length ) & hash

        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

通过除留余数法方式获取桶号，因为Hash表的大小始终为2的n次幂，因此可以将取模转为位运算操作，提高效率，这就是按照2倍方式扩容的一个原因

8.扩容机制

将cap扩展到大于cap最近的2的n次幂

	static final int tableSizeFor(int cap) {
	int n = cap - 1;
	n |= n >>> 1;
	n |= n >>> 2;
	n |= n >>> 4;
	n |= n >>> 8;
	n |= n >>> 16;
	return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
	}

9.构造方法

（1）参数为初始容量，负载因子使用默认值0.75

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

（2）无参
容量使用默认初始值16，负载因子使用默认值0.75

public HashMap(){
	this.loadFactor = DEFAULT_LOAD_FACTOR;
}

（3）参数为初始容量和初始负载因子

public HashMap(int initalCapacity,float loadFactor){
	//如果容量小于0，抛出非法参数异常
	if(initialCapacity < 0){
    	throw new IllegalArgumentException("Illegal initial capacity: "+initalCapacity);
    }
    
    //若初始值容量大于最大值，使用2^30替换
    if(initialCapacity > MAXMUM_CAPACITY)
    	initialCapacity = MAXIMUM_CAPACITY;
    
    //若负载因子小于0或非浮点数，抛出非法参数异常
    if(loadFactor <= 0 || Float.isNaN(loadFactor))
    	throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
    // 给负载因子和容量赋值，并将容量提升到2的整数次幂
	// 注意：构造函数中并没有给
	this.loadFactor = loadFactor;
	this.threshold = tableSizeFor(initialCapacity);//扩容至最近的2的整数次幂
}
/*
注意：
不同于Java7中的构造方法，Java8对于数组table的初始化，并没有直接放在构造器中完成，而是将table数组的构
造延迟到了resize中完成
*/
    
   
}

java8在HashMap的构造函数中：并没有开辟空间，而是将开辟空间延迟到第一次插入元素时。
10.根据key获取value

（1）根据key计算出哈希地址，然后用哈希地址在哈希桶中找到与key对应的结点
（2）若结点为null，返回null。HashMap中结点可以为null
（3）若结点不为空，返回该结点中的value

  /**
     * Implements Map.get and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
public V get(Object key){
	Node<K,V> e;
	return (e = getNode(hash(key),key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash,Object key){
	Node<K,V>[] tab;
	Node<K,V> first,e;
	int n;
	K k;
	//1.检测哈希桶是否为空
	//2.检测哈希桶的个数是否大于0，若桶不空，桶的个数肯定不为0
	//3.n-1 & hash 得到桶号，且不为null
	//4.当前桶是否为空
	//1.2.3.4均成立，说明当前桶中有结点，拿到当前桶中第一个结点。
	if((tab = table) != null && (n = tab.length) > 0 && (first = [tab[(n-1) & hash)] != null){
	    //若结点的哈希值与key的哈希值相等，然后再检测key是否相等
	    //1.若相等，则返回该节点
	    //可以重写hashcode方法和equals方法
	    //        比较的是地址
		if(first.hash == hash && ((k = first.key) == key ||(key != null && key.equals(k))))
			return first;
        //若first后还有结点
		if((e = first.next) != null){
			//检测first是否为TreeNode类型的
 		    //若为TreeNode，此时应在红黑树中好与key对应的结点
			if(first instanceof TreeNode)
				return ((TreeNde<K,V> first).getTreeNode(hash,key);
			//若桶中挂接的是单链表，则按照以下方式查找
			//顺着链表的结点一个一个的往下找，找到之后返回
			do{
				if(e.hash == hash && 
					((k = e.key) == key || (key != null && key.equals(k))))
					return e;
			}while((e = e.next) != null);
		}
	}
	return null;
}

11.检测key是否存在

（1）先通过getNode（）获取与key对应的节点
（2）如果节点不为空，则说明存在返回true，否则返回false
（2）时间复杂度：平均为o（1），如果当前key所对应的桶中挂接的链表则进行顺序查找，如果挂接的是红黑树，则按照红黑树的性质查找。

public boolean containsKey(Object key) {
	return getNode(hash(key), key) != null;
}

12.插入结点

（1）先使用key借助hash函数计算key的哈希地址
（2）将key-value键值对，结合计算出的hash地址插入到哈希桶中
（3）HashMap在插入时，并没有处理线程安全问题，因此HashMap是非线程安全的
（4）红黑树优化链表过长是java8新引进，是基于性能的考虑，当冲突大时，红黑树比链表的效率高，综合表现更好。

public V put(K key,V valye){
	return putVal(hash(key),key,value,false,true);
}

final V putVal(int hash,K key,V value,boolean onlyIfAbsent,boolean evict){
	Node<K,V>[] tab;
	Node<K,V> p;
	int n,i;
	
	//若桶是空的，则直接进行扩容
	if((tab = table) == null || (n = tab.length) == 0)
		n = (table = resize()).length;
	
	//(n-1) & hash 计算桶号，如果当前桶中没有节点，直接插入
	//p来记录桶中的第一个结点
	if(( p =tab[i = (n-1) & hash]) == null)
		tab[i] = new Node(hash,key,value,null);
	else{
		Node<K,V> e;
		K k;
		//如果key与桶中的第一个结点相等，不进行插入
		if(p.hash == hash &&
			((k = p.key ) == key || (key != null && key.equals(k))))
			e = p;
		else if(p instanceof TreeNode)
		    //当前桶挂接的是红黑树时，使用红黑树插入结点方法
			e = ((TreeNode<K,V>) p).putTreeVal(this,tab,hash,key,value);
		else{
			//当前桶中挂接的是一个链表
			//1.在当前链表中找key
			//找到，不插入
			//没有找到，构建新节点，然后将其尾插到链表
			//检测binCount的计数，binCount记录的是在未插入新节点前链表的节点个数
			//新节点插入后，链表长度是否超过TREEIFY_THRESHOLD（树阈值），若超过，又将其转化为红黑树。
			for(int binCount = 0; ;++binCount){
				if(( e = p.next ) == null){
					//p是最后一个节点，说明在链表中未找到key对应的结点
					//进行尾插
					p.next = new Node(hash,key,value,null);
					if(binCount>=TREEIFY_THRESHOLD - 1)
						treeifyBin(tab,hash);//将链表转化为树、
					break;
				}
				//如果key已经存在，跳出循环
				if(e.hash == hash &&
					((k = e.key) == key || (key != null && key.equals(k))))
					break;
				p = e;
			}
		}
		//如果key已经存在，将key所对应的结点中的value替换为参数指定的value，返回旧的value
		if( e != null){
			V oldValue = e.value;
			if(!onlyIfAbsent || oldValue == null)
				e.value = value;
			afterNodeAccess(e);
			return oldValue;
		}
	}
	++modCount;
	if(++size>threshold)
		resize();
	afterNodeInsertion(evict);
	return null;
   /*afterNodeAccess和afterNodeInsertion主要是LinkedHashMap实现的，HashMap中给出了该方法，但是并没有实现。
   */
 //访问。插入。删除结点后进行一些处理
 //linkedHashMap通过重写这3个方法来保证链表的插入删除的有序性
 void afterNodeAccess(Node<K,V> p) { }
 void afterNodeInsertion(boolean evict) { }
 void afterNodeRemoval(Node<K,V> p) { }
  /**
  LinkedHashMap:继承了HashMap，在LinkedHashMap中会对以上方法进行重写，以保证存入到LinkedHashMap中的key是有序的，有序不是指自然序列的有序性，而是指元素插入的先后有序性。
  **/
}

在java7中，于链表中插入新结点采用头插法，在多线程的情况下会出现死循环
在java8中采用尾插法，解决了头插法在多线程情况下出现的死循环问题，但HashMap在多线程情况下，还是不安全的。

13.LinkedHashMap

底层哈希桶使用的是双向链表

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
{
	/**
	* HashMap.Node subclass for normal LinkedHashMap entries.
	*/
	static class Entry<K,V> extends HashMap.Node<K,V> {
		Entry<K,V> before, after;
		Entry(int hash, K key, V value, Node<K,V> next) {
			super(hash, key, value, next);
		}
	}
	private static final long serialVersionUID = 3801124242820219131L;
	/**
	* The head (eldest) of the doubly linked list.
	*/
	transient LinkedHashMap.Entry<K,V> head;
	/**
	* The tail (youngest) of the doubly linked list.
	*/
	transient LinkedHashMap.Entry<K,V> tail;
	/**
	* The iteration ordering method for this linked hash map: <tt>true</tt>
	* for access-order, <tt>false</tt> for insertion-order.
	*
	* @serial
	*/
	// true: 按照访问次序排序-LRU
	// false：按照插入次序排序
	final boolean accessOrder;
	/**
	* Constructs an empty <tt>LinkedHashMap</tt> instance with the
	* specified initial capacity, load factor and ordering mode.
	*
	* @param initialCapacity the initial capacity
	* @param loadFactor the load factor
	* @param accessOrder the ordering mode - <tt>true</tt> for
	* access-order, <tt>false</tt> for insertion-order
	* @throws IllegalArgumentException if the initial capacity is negative
	* or the load factor is nonpositive
	*/
	public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder) {
		super(initialCapacity, loadFactor);
		this.accessOrder = accessOrder;
	}
    // ...
    void afterNodeInsertion(boolean evict) { // possibly remove eldest
		LinkedHashMap.Entry<K,V> first;
		if (evict && (first = head) != null && removeEldestEntry(first)) {
			K key = first.key;
			removeNode(hash(key), key, null, false, true);
		}
	}
	protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
		return false;
	}
	/**根据以上代码发现，afterNodeInsertion由于removeEldestEntry()所返回的false没有执行意义，所以想要使它有意义就必须重写removeEldestEntry
	若使用LinkedHashMap实现一个简单的LRU（Least Recently Used 最近最少使用）Cache。则要重写removeEldestEntry()当超出缓存容器大小时移除最老的首节点。
	*/

}

• linkedHashMap继承了HashMap，且实现Map接口
• LinkedHashMap底层使用了哈希桶和双向链表两种结果
• LinkedHashMap需要重写HashMap中的：afterNodeInsertion/afterNodeAccess /afterNodeRemove 等方法
• LinkedHashMap使用迭代器访问时，可以保证一个有序（指的是插入的先后次序）的结果
• 向哈希表中重复插入某个键的时候，不会影响到原来的有序性。
• LinkedHashMap可以作为LRU使用，但要在重写removeEldestEntry方法的前提下。

14.删除key

删除成功：返回删除的key的value
删除失败：返回null

public V remove(Object key){
	Node<K,V> e;
	return (e = removeNode(hash(key),key,null,false,true)) == null ? null:e.value;

}


final Node<K,V>  removeNode(int hash,Object key,Object value,boolean value,boolean matchValue,boolean movable){
		Node<K,V>[] tab;
		Node<K,V> p;
		int n,index;
		
		//检测哈希表是否存在
		//index  = (n-1)&hash获取桶号
		//使用p记录当前桶中的第一个节点，如果桶中没有结点，返回null
		if((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n-1)&hash]) != null){
			Node<K,V> node = null,e;
			K k;
			V v;
			
			//如果第一个结点为key，返回，使用node记录
			if (p.hash == hash &&
			((k = p.key) == key || (key != null && key.equals(k))))
				node = p;
			else if ((e = p.next) != null) {
				// 如果当前桶下是红黑树，在红黑树中查找，结果用node记录
				if (p instanceof TreeNode)
					node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
				else {
					do{
						if(e.hash == hash && ((k = e.key) == key || (key!=null && key.equals(k)))){
							node = e;
							break;
					}
					p = e;
				}while((e = e.next) != null);	
			}
	}
     // node不为空，在HashMap中找到了
	if (node != null && (!matchValue || (v = node.value) == value ||
	(value != null && value.equals(v)))) {
		// 如果节点在红黑树中，将其删除
			if (node instanceof TreeNode)
				((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
			// 如果节点是链表中第一个节点，将当前链表中下一个节点地址放在桶中
		else if (node == p)
			tab[index] = node.next;
		else
			p.next = node.next; // 非第一个节点
		++modCount;
		--size;
		// LinkedHashMap使用
		afterNodeRemoval(node);
		// 删除成功，返回原节点
		return node;
		}
	}
	// 删除失败返回空
	return null;

}

15.resize扩容

java8中的扩容，不是简单的将原数组中的每一个元素取出进行重写hash，而是做移位检测。
扩容：

• 计算新容量大小
• 开辟新空间
• 将旧桶中的元素转移到新哈希桶中。
  • 传统做法：从旧桶中取node ，重新计算node在新桶中的位置
  • java8中：拿到1个node就知道它在新桶中的位置：原因：容量是2的整数次幂
    可以直接检测扩容后的那一位是否是1.

final Node<K,V>[] resize() {
	Node<K,V>[] oldTab = table;
	int oldCap = (oldTab == null) ? 0 : oldTab.length;
	int oldThr = threshold;
	int newCap, newThr = 0;
	if (oldCap > 0) {
	// 如果当前哈希桶容量超过最大值2^30，直接返回旧哈希桶大小
	// 到达上线 threshold 设置最大阈值返回 表示之后就不再扩容了，随便存，随便hash冲
	// 突去，就这么大，无限增加红黑树节点了
	if (oldCap >= MAXIMUM_CAPACITY) {
		threshold = Integer.MAX_VALUE;
		return oldTab;
	}
	// 按照两倍扩容后，如果容量没有达到上限
	// 并且旧容量已经超过16
	// newCap翻倍，则按照两倍的方式扩容
	else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
	oldCap >= DEFAULT_INITIAL_CAPACITY)
	// 下一次扩容时参考，达到该阈值则扩容
	newThr = oldThr << 1; // double threshold
	}
	else if (oldThr > 0) // initial capacity was placed in threshold
	newCap = oldThr;
	else { // zero initial threshold signifies using defaults
	// 将新容量设置为默认值16
	// 将扩容阈值设置为0.75*16
	newCap = DEFAULT_INITIAL_CAPACITY;
	newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
	}
	// 如果新阈值为0，按照新容量的大小重新计算下一次扩容时的阈值
	// 计算方式：采用新容量 * 负载因子
	// 即扩容的时机为：当元素个数超过阈值时则扩容
	if (newThr == 0) {
	float ft = (float)newCap * loadFactor;
	// 如果新容量和阈值都是在2^30以内，下一次库哦哦荣的阈值则为ft
	// 否则改为最大值
	newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
	(int)ft : Integer.MAX_VALUE);
	}
	// 更新下次扩容的上线
	threshold = newThr;
	@SuppressWarnings({"rawtypes","unchecked"})
	// // 申请更多的桶，将旧哈希桶中节点转移到新哈希桶中
	Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
	table = newTab;
	if (oldTab != null) {
	for (int j = 0; j < oldCap; ++j) {
	Node<K,V> e;
	if ((e = oldTab[j]) != null) {
	oldTab[j] = null;
	if (e.next == null)
	newTab[e.hash & (newCap - 1)] = e;
	else if (e instanceof TreeNode)
	((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
	else { // preserve order
	Node<K,V> loHead = null, loTail = null;
	Node<K,V> hiHead = null, hiTail = null;
	Node<K,V> next;
	do {
	next = e.next;
	if ((e.hash & oldCap) == 0) {
	if (loTail == null)
	loHead = e;
	else
	loTail.next = e;
	loTail = e;
	}
	else {
	if (hiTail == null)
	hiHead = e;
	else
	hiTail.next = e;
	hiTail = e;
	}
	} while ((e = next) != null);
	if (loTail != null) {
	loTail.next = null;
	newTab[j] = loHead;
	}
	if (hiTail != null) {
	hiTail.next = null;
	newTab[j + oldCap] = hiHead;
	}
	}
	}
	}
	}
	return newTab;
	}

16.HashMap常考问题

（1）如果new HashMap(19)，bucket数组多大？

HashMap的bucket 数组大小一定是2的幂，如果new的时候指定了容量且不是2的幂，实际容量会是最接近(大于)指定容量的2的幂，比如 new HashMap<>(19)，比19大且最接近的2的幂是32，实际容量就是32。

（2）HashMap什么时候开辟bucket数组占用内存？

HashMap在new 后并不会立即分配bucket数组，而是第一次put时初始化，类似ArrayList在第一次add时分配空间

（3）HashMap何时扩容？

HashMap 在 put 的元素数量大于 Capacity * LoadFactor（默认16 * 0.75） 之后会进行扩容

（4）当两个对象的hashcode相同时会发生什么？

因为hashcode相同，所以它们的bucket位置相同，‘碰撞’会发生
（在深入解释）
（5）如果两个键的hashcode相同，你如何获取值对象？

遍历与hashCode值相等时相连的链表，直到相等或者为null

（6）你了解重新调整HashMap大小存在什么问题吗？
当hashMap中的节点数超过阈值的时候，就会自动扩容，扩容的时候就会调整hashMap的大小，一旦调整了hashMap的大小就会导致之前的hashCode计算出来的hash表中下标无效，所以所有的节点都需要重新hash运算，结果就是带来时间上的浪费。因此我们要尽量避免hashMap调整大小，所以我们使用hashMap的时候要给hashMap设置一个默认值，这个默认值要大于我们hashMap中存放的节点数。

（7）containsKey（）的时间复杂度：O（1）（链表）或O（logN）（红黑树）