jdk8源码5---集合4---HashMap
本来是想写HashSet,但是看了HashSet的成员变量,你就懂了、、、、、
一、签名
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { |
HashMap通常作为桶式哈希表,当桶变得很大的时候就转化为树节点。一般达到过量数据的时机比较少。所以在桶式哈希表中会尽量推迟树形节点的检测。
树形哈希(所有节点都是树节点),以哈希值排序,但如果都是同类型并且该类型实现了比较器就以比较器的结果为准。TreeNode是一般节点的两倍。只有当哈希表节点数达到一定数量才使用。
通常第一个节点作为树的根节点,当根节点移除时才更换。
不论哈希列表还是树形哈希,分割还是非树形,都保证相对的访问遍历顺序。
二、成员变量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 初始大小16 |
static final int MAXIMUM_CAPACITY = 1 << 30; // 最大容量 |
static final float DEFAULT_LOAD_FACTOR = 0.75f; //负载系数(装载因子) 主要控制空间利用率和冲突。装载因子越大空间利用率更高,冲突可能也会变大,反之则相反。 |
static final int TREEIFY_THRESHOLD = 8; //由链表转换成树的阈值、 |
static final int UNTREEIFY_THRESHOLD = 6; // 由树转换成链表的阈值 |
static final int MIN_TREEIFY_CAPACITY = 64; //转换树形后表格最小容量,至少是treeify_threshold的四倍。 |
static class Node<K,V> implements Map.Entry<K,V> { //基本的哈希容器节点。 final int hash; // 不可变的hash值,由关键字key得来。 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; } } |
transient Node<K,V>[] table; // 不被序列化的节点。Node类型数组,第一次使用的时候初始化,必要时重新分配空间。长度总是2的次幂。 |
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; } } |
transient Set<Map.Entry<K,V>> entrySet; // 缓存所有的EntrySet() |
transient int size; // 当前map中的数据量 |
transient int modCount; // map结构的修改次数。实现了fast-fial策略。 |
int threshold; // 下次重新分配空间resize()时,table数组的大小。 |
Final float loadFactor; // hash表的负载因子。 |
三、静态工具函数。
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } // 学习一下编码风格(标红处)。 |
计算key的hash值,并且将高位的hash值移到低位。因为使用的掩码是2的n次幂,高于掩码的位组成的哈希集合总是冲突,所以要把高位移到低位。
static Class<?> comparableClassFor(Object x) { if (x instanceof Comparable) { Class<?> c; Type[] ts, as; Type t; ParameterizedType p; if ((c = x.getClass()) == String.class) // bypass checks return c; if ((ts = c.getGenericInterfaces()) != null) { for (int i = 0; i < ts.length; ++i) { if (((t = ts[i]) instanceof ParameterizedType) && ((p = (ParameterizedType)t).getRawType() == Comparable.class) && (as = p.getActualTypeArguments()) != null && as.length == 1 && as[0] == c) // type arg is c return c; } } } return null; } |
与x进行比较,如果x是可比较类型,返回x的类型,否则返回null。
static int compareComparables(Class<?> kc, Object k, Object x) { return (x == null || x.getClass() != kc ? 0 : ((Comparable)k).compareTo(x)); } |
如果x和k可以比较,返回k和x的比较结果,否则返回0.
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; } |
对于给定的目标容器返回一个2的次幂容量(返回大于cap的最小的2次幂)感觉这个地方很深奥。
百度一张图片吧:
四、构造方法
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); this.loadFactor = loadFactor; this.threshold = tableSizeFor(initialCapacity); } |
根据特定的初始化容量和负载因子的构造函数。
public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } |
根据指定初始化容量和默认装载因子.75的构造函数
public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } |
构造一个默认大小和默认装载因子的HashMap。
public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); } |
五、成员方法
public V put(K key, V value) { 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; // 如果table为空的话,就先初始化,扩容。 if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) // 如果tab[i]为空,直接放入。 tab[i] = newNode(hash, key, value, null); else { // 如果hash后的位置上的值不为空。后接链表。 Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) // key已经存在。 e = p; else if (p instanceof TreeNode) // 如果该节点属于红黑树。(链表的长度>8) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else {// tab[i]后还是链表。 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))))//如果key已经存在,就覆盖value。 break; p = e; } }
//如果之前判断到key已经存在,就进行覆盖value 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; } |
扩容机制: 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) { if (oldCap >= MAXIMUM_CAPACITY) { // 如果原来table中容量已经是最大 threshold = Integer.MAX_VALUE; return oldTab; } // 如果旧容量*2小于最大容量阈值,并且旧容量大于默认初始化容量。 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // 新的容量阈值扩大两倍。 } else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { float ft = (float)newCap * loadFactor; 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) { // 把每个table[i]都移动到新的newtable[i]中。 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 { // 原索引+oldCap 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; } |
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab, int h, K k, V v) { Class<?> kc = null; boolean searched = false; TreeNode<K,V> root = (parent != null) ? root() : this; for (TreeNode<K,V> p = root;;) { int dir, ph; K pk; if ((ph = p.hash) > h) dir = -1; else if (ph < h) dir = 1; else if ((pk = p.key) == k || (k != null && k.equals(pk))) return p; else if ((kc == null && (kc = comparableClassFor(k)) == null) || (dir = compareComparables(kc, k, pk)) == 0) { if (!searched) { TreeNode<K,V> q, ch; searched = true; if (((ch = p.left) != null && (q = ch.find(h, k, kc)) != null) || ((ch = p.right) != null && (q = ch.find(h, k, kc)) != null)) return q; } dir = tieBreakOrder(k, pk); }
TreeNode<K,V> xp = p; if ((p = (dir <= 0) ? p.left : p.right) == null) { Node<K,V> xpn = xp.next; TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn); if (dir <= 0) xp.left = x; else xp.right = x; xp.next = x; x.parent = x.prev = xp; if (xpn != null) ((TreeNode<K,V>)xpn).prev = x; moveRootToFront(tab, balanceInsertion(root, x)); return null; } } } |
分析:
图片来源于网络,见注释。
public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } |
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } |
final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; 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; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) { 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); } } 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; afterNodeRemoval(node); return node; } } return null; } |
六、遍历方法
这里总结一下Map的遍历方法吧,for,fori,iterator什么的统统不算哈。
就只有两种。一种是entry,一种是getKey。
举个栗子:一对夫妻,你想找个那个妻子。。。。。。一种找到他老公,通过他老公去找,第二种是直接拿到他俩的结婚证找到妻子。
1. hashMap.keySet(); for set…………就是for循环的方式了。
2. hashMap.entrySet();
总结
hashMap根据键的hashCode值存储数据,大多数情况下可以直接定位它的值。大多数情况下可以直接定位它的值,因而具有很快的访问速度。但是遍历顺序却是不确定的。hashMap最多只允许一条记录的键为null,允许多条记录的值为null。hashMap非线程安全,即任一时刻可以有多个线程同时写HashMap,可能会导致数据的不一致,但是可以用Collections.synchronizedMap()使HashMap线程安全。
或者使用ConcurrentHashMap。
要搞清楚HashMap,首先要清楚HashMap是什么,即它的存储结构-字段,其次弄明白它能干什么,即它的功能实现-方法。
Jdk8中,HashMap是数组+链表+红黑树实现的,如下图。
那么问题来了,数据底层存储的是什么呢?这样的存储方式有什么好处呢?
1.hashMap有一个很重要的字段,就是Node<K,V>.这个Node的实现,见上面的字段介绍。
途中每个黑点就是一个Node。
2.大家都知道HashMap的底层数据结构使哈希表,哈希表为解决冲突,可以采用开发地址法和链地址法等来解决问题,java中HashMap采用了链地址法。当数据被hash后,得到数组下标,把数据放在对应下标元素的链表上。
3.根据源码,threshold就是在此loadFactor和length对应下允许的最大元素数目,超过这个数目就要重新扩容,扩容后的HashMap容量就是之前容量的两倍。默认的loadFactor是0.75,是对空间和时间的平衡选择,。如果内存空间很多而对事件效率要求很高,可以降低loadFactor的值。想反,对内存空间比较紧张而对时间效率要求不高的时候,就可以增加loadFactor的值,这个值可以大于1.
4.为什么hashMap的重新扩容或者初始化大小是2的n次方呢?
在HashMap中,哈希桶数组table的长度length大小必须为2的n次方(一定是合数),这是一种非常规的设计,常规的设计是把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数,具体证明可以参考http://blog.csdn.net/liuqiyao_01/article/details/14475159,Hashtable初始化桶大小为11,就是桶大小设计为素数的应用(Hashtable扩容后不能保证还是素数)。HashMap采用这种非常规设计,主要是为了在取模和扩容时做优化,同时为了减少冲突,HashMap定位哈希桶索引位置时,也加入了高位参与运算的过程。
5.哈希算法:
这里的Hash算法本质上就是三步,取key的hashCode值,,高位运算,取模运算。
对于任意的对象,只要hashCode()的值相同,那么计算所得的hash码也是相同的,我们把hash值对数组的长度取模,但是取模的消耗很大,hashMap采用h&(length-1)的方式。
这个方法非常巧妙,它通过h & (table.length -1)来得到该对象的保存位,而HashMap底层数组的长度总是2的n次方,这是HashMap在速度上的优化。当length总是2的n次方时,h& (length-1)运算等价于对length取模,也就是h%length,但是&比%具有更高的效率。
6.扩容机制:
我们使用的是2次幂的扩展(指长度扩为原来的2倍)所以,元素的位置要么是在原位置,要么是在原位置在移动2次幂的位置。
图a,表示扩容前的key1和key2两种key确定索引的位置,
图b,表示扩容后的key1和key2两种key确定索引位置的示例。
元素在重新计算hash之后,因为n变为2倍,那么n-1的mask范围在高位多1bit(红色),因此新的index就会发生这样的变化:
因此,我们在扩充HashMap的时候,不需要像JDK1.7的实现那样重新计算hash,只需要看看原来的hash值新增的那个bit是1还是0就好了,是0的话索引没变,是1的话索引变成“原索引+oldCap”,可以看看下图为16扩充为32的resize示意图:
这个设计确实非常的巧妙,既省去了重新计算hash值的时间,而且同时,由于新增的1bit是0还是1可以认为是随机的,因此resize的过程,均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。
1. 线程安全机制:
线程不安全,多线程环境中应尽量使用ConcurrentHashMap。
(1) 扩容是一个特别耗性能的操作,所以当程序员在使用HashMap的时候,估算map的大小,初始化的时候给一个大致的数值,避免map进行频繁的扩容。
(2) 负载因子是可以修改的,也可以大于1,但是建议不要轻易修改,除非情况非常特殊。
(3) HashMap是线程不安全的,不要在并发的环境中同时操作HashMap,建议使用ConcurrentHashMap。
(4) JDK1.8引入红黑树大程度优化了HashMap的性能。
(5) 还没升级JDK1.8的,现在开始升级吧。HashMap的性能提升仅仅是JDK1.8的冰山一角。
借鉴文章:http://www.importnew.com/20386.html (通过这篇文章,知道了什么才是在学习)