1 概述
HashMap是基于哈希表实现的,每一个元素是一个key-value对,其内部通过单链表解决冲突问题,容量不足(超过了阀值)时,同样会自动增长.
HashMap是非线程安全的,只适用于单线程环境,多线程环境可以采用并发包下的concurrentHashMap
HashMap 实现了Serializable接口，因此它支持序列化，实现了Cloneable接口，能被克隆
HashMap是基于哈希表的Map接口的非同步实现.此实现提供所有可选的映射操作,并允许使用null值和null键.此类不保证映射的顺序,特别是它不保证该顺序恒久不变.
Java8中又对此类底层实现进行了优化，比如引入了红黑树的结构以解决哈希碰撞
2 HashMap的数据结构
在Java中,最基本的结构就是两种,一个是数组,另外一个是模拟指针(引用),所有的数据结构都可以用这两个基本结构来构造,HashMap也不例外.
HashMap实际上是一个"链表散列"的数据结构,即数组和链表的结合体.
HashMap的主结构类似于一个数组,添加值时通过key确定储存位置.
每个位置是一个Entry的数据结构,该结构可组成链表.
当发生冲突时,相同hash值的键值对会组成链表.
这种数组+链表的组合形式大部分情况下都能有不错的性能效果,Java6、7就是这样设计的.
然而,在极端情况下,一组（比如经过精心设计的）键值对都发生了冲突，这时的哈希结构就会退化成一个链表，使HashMap性能急剧下降.
所以在Java8中,HashMap的结构实现变为数组+链表+红黑树
可以看出,HashMap底层就是一个数组结构
数组中的每一项又是一个链表
当新建一个HashMap时,就会初始化一个数组.
3 三大集合与迭代子
HashMap使用三大集合和三种迭代子来轮询其Key、Value和Entry对象
public class HashMapExam { public static void main(String[] args) { Map map = new HashMap(16); for (int i = 0; i < 15; i++) { map.put(i, new String(new char[]{(char) ('A'+ i)})); } System.out.println("======keySet======="); Set set = map.keySet(); Iterator iterator = set.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } System.out.println("======values======="); Collection values = map.values(); Iterator stringIterator=values.iterator(); while (stringIterator.hasNext()) { System.out.println(stringIterator.next()); } System.out.println("======entrySet======="); for (Map.Entry entry : map.entrySet()) { System.out.println(entry); } } }
4 源码分析
//默认的初始容量16,且实际容量是2的整数幂 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //最大容量(传入容量过大将被这个值替换) static final int MAXIMUM_CAPACITY = 1 << 30; // 默认加载因子为0.75(当表达到3/4满时,才会再散列),这个因子在时间和空间代价之间达到了平衡.更高的因子可以降低表所需的空间,但是会增加查找代价,而查找是最频繁操作 static final float DEFAULT_LOAD_FACTOR = 0.75f; //桶的树化阈值：即 链表转成红黑树的阈值，在存储数据时，当链表长度 >= 8时，则将链表转换成红黑树 static final int TREEIFY_THRESHOLD = 8; // 桶的链表还原阈值：即 红黑树转为链表的阈值，当在扩容（resize（））时（HashMap的数据存储位置会重新计算），在重新计算存储位置后，当原有的红黑树内数量 <= 6时，则将 红黑树转换成链表 static final int UNTREEIFY_THRESHOLD = 6;
因为红黑树的平均查找长度是log(n)，长度为8的时候，平均查找长度为3，如果继续使用链表，平均查找长度为8/2=4，这才有转换为树的必要
链表长度如果是小于等于6，6/2=3，虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短
还有选择6和8，中间有个差值7可以有效防止链表和树频繁转换
假设一下，如果设计成链表个数超过8则链表转换成树结构，链表个数小于8则树结构转换成链表，如果一个HashMap不停的插入、删除元素，链表个数在8左右徘徊，就会频繁的发生树转链表、链表转树，效率会很低。
//最小树形化容量阈值：即 当哈希表中的容量 > 该值时，才允许树形化链表 （即 将链表 转换成红黑树） // 为了避免扩容/树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD // 小于该值时使用的是扩容哦!!! static final int MIN_TREEIFY_CAPACITY = 64; // 存储数据的Node数组,长度是2的幂. // HashMap采用链表法解决冲突，每一个Node本质上是一个单向链表 //HashMap底层存储的数据结构,是一个Node数组.上面得知Node类为元素维护了一个单向链表.至此,HashMap存储的数据结构也就很清晰了:维护了一个数组,每个数组又维护了一个单向链表.之所以这么设计,考虑到遇到哈希冲突的时候,同index的value值就用单向链表来维护 //与 JDK 1.7 的对比（Entry类），仅仅只是换了名字 transient Node[] table; // HashMap的底层数组中已用槽的数量 transient int size; // HashMap的阈值，用于判断是否需要调整HashMap的容量（threshold = 容量*加载因子） int threshold; // 负载因子实际大小 final float loadFactor; // HashMap被改变的次数 transient int modCount; // 指定“容量大小”和“加载因子”的构造函数,是最基础的构造函数 public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); // HashMap的最大容量只能是MAXIMUM_CAPACITY if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; //负载因子须大于0 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); // 设置"负载因子" this.loadFactor = loadFactor; // 设置"HashMap阈值",当HashMap中存储数据的数量达到threshold时,就需将HashMap的容量加倍 this.threshold = tableSizeFor(initialCapacity); }
- 上面的tableSizeFor有何用?
tableSizeFor方法保证函数返回值是大于等于给定参数initialCapacity最小的2的幂次方的数值
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 = MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }
a |= b 等同于 a = a|b
逐行分析
- int n = cap - 1
给定的cap 减 1,为了避免参数cap本来就是2的幂次方,这样一来,经过后续操作，cap将会变成2 * cap,是不符合我们预期的 - n |= n >>> 1
n >>> 1 : n无符号右移1位,即n二进制最高位的1右移一位
n | (n >>> 1) 导致 n二进制的高2位值为1
目前n的高1~2位均为1 - n |= n >>> 2
n继续无符号右移2位
n | (n >>> 2) 导致n二进制表示的高34位经过运算值均为1
目前n的高14位均为1 - n |= n >>> 4
n继续无符号右移4位
n | (n >>> 4) 导致n二进制表示的高58位经过运算值均为1
目前n的高18位均为1 - n |= n >>> 8
n继续无符号右移8位
n | (n >>> 8) 导致n二进制表示的高916位经过运算值均为1
目前n的高116位均为1
可以看出,无论给定cap(cap < MAXIMUM_CAPACITY )的值是多少,经过以上运算,其值的二进制所有位都会是1.再将其加1,这时候这个值一定是2的幂次方.
当然如果经过运算值大于MAXIMUM_CAPACITY,直接选用MAXIMUM_CAPACITY.
至此tableSizeFor如何保证cap为2的幂次方已经显而易见了,那么问题来了
4.1 为什么cap要保持为2的幂次方？
主要与HashMap中的数据存储有关.
在Java8中,HashMap中key的Hash值由Hash(key)方法计得
HashMap中存储数据table的index是由key的Hash值决定的.
在HashMap存储数据时,我们期望数据能均匀分布,以防止哈希冲突.
自然而然我们就会想到去用%取余操作来实现我们这一构想
取余(%)操作 : 如果除数是2的幂次则等价于与其除数减一的与(&)操作.
这也就解释了为什么一定要求cap要为2的幂次方.再来看看table的index的计算规则
newTab[e.hash & (newCap-1)]=e; 等价于: index = e.hash % newCap
采用二进制位操作&,相对于%,能够提高运算效率,这就是cap的值被要求为2幂次的原因
树形化链表的两个条件：①链表长度大于8,② 哈希表总容量大于最小树形话容量阀值
4.2 Node类
static class Node implements Map.Entry { final int hash; final K key; V value; Node next; Node(int hash, K key, V value, Node 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; } }
Node 类是HashMap中的静态内部类,实现Map.Entry接口.定义了key键、value值、next节点,也就是说元素之间构成了单向链表.
4.3 TreeNode
static final class TreeNode extends LinkedHashMap.Entry { TreeNode parent; // red-black tree links TreeNode left; TreeNode right; TreeNode prev; // needed to unlink next upon deletion boolean red; TreeNode(int hash, K key, V val, Node next) {} // 返回当前节点的根节点 final TreeNode root() { for (TreeNode r = this, p;;) { if ((p = r.parent) == null) return r; r = p; } } }
红黑树结构包含前、后、左、右节点，以及标志是否为红黑树的字段
此结构是Java8新加的
