一、HashMap 简介
前面介绍了LinkedList和ArrayList两个常用的集合,这次介绍的是另外一个常用的集合HashMap。HashMap继承了AbstractMap, 实现了Map,Cloneable, Serializable接口,使用的是键(key)-值(value)对存储方式,key和value都允许为null,key不允许重复 。
二、 HashMap 的数据结构
JDK1.8之前的HashMap是使用数组 + 链表作为数据结构,利用key的hashCode来计算hash值,再跟数组长度 - 1进行按位与得出在数组的下标,但是因为计算出来的下标有可能一样,特别是在存储的数量多的情况下一样的几率就更高了,所以在JDK1.8之前使用链表来存储计算出来下标一样的元素。但是链表的查询速度较慢,在JDK1.8对HashMap做了优化,使用数组 + 链表 + 红黑树来存储,当链表的长度大于8的时候,会转成红黑树,红黑树是一种 平衡二叉查找树 ,有较高的查找性能,有兴趣的朋友可以去了解下。
三、HashMap 源码解析
HashMap的源码有2000多行,再加上笔者能力有限,所以接下来就对一些主要的方法和属性进行解析
(一) HashMap 的属性
// 默认的数组长度 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 // 数组最大长度 2 的 30次方 static final int MAXIMUM_CAPACITY = 1 << 30; // 默认加载因子 static final float DEFAULT_LOAD_FACTOR = 0.75f; // 当链表的长度大于 8 有可能转换成红黑树 static final int TREEIFY_THRESHOLD = 8; // 在容器进行扩容时发现红黑树的长度小于 6 时会转回链表 static final int UNTREEIFY_THRESHOLD = 6; // 在转变成树之前,还会有一次判断,当键-值对数量大于 64 才会转换。这是为了避免在哈希表建立初期,多个键-值对恰 // 好被放入了同一个链表中而导致不必要的转化 static final int MIN_TREEIFY_CAPACITY = 64; // Node节点的数组,主要容器 transient Node<K,V>[] table; //缓存entrySet() transient Set<Map.Entry<K,V>> entrySet; // HashMap的大小,也就是存储键-值对的数量 transient int size; // HashMap修改的次数 transient int modCount; // 阈值,threshold = 容量(table.length) * 加载因子, 当HashMap中存储的键-值对数量大于这个的时候进行扩容 int threshold; // 加载因子,默认0.75f,加载因子越低的话容器中的空闲空间越多,冲突机会较少,查询较快 // 加载因子越高的话容器中填满的元素更多了,减少了空间的开销,但元素跟元素之间的冲突就多了,冲突的话 // 会生成链表或红黑树,所以查询就慢了 final float loadFactor;
(二) 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); this.loadFactor = loadFactor; // 初始化容量 this.threshold = tableSizeFor(initialCapacity); } // capacity必须满足2的N次方,如果在构造函数内指定的容量cap不满足, // 通过下面的算法将其转换为大于n的最小的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; } // 带初始化容量 public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } // 空参数构造函数 public HashMap() { // 使用默认的加载因子 this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted } // 参数为Map的构造函数,将另外一个Map的元素添加到容器中 public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; // 将另外一个Map的元素添加到容器中 putMapEntries(m, false); } // 将另外一个Map的元素添加到容器中 final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) { int s = m.size(); if (s > 0) { // 判断table是否为空 if (table == null) { // pre-size // 未初始化,计算 m 的容量 float ft = ((float)s / loadFactor) + 1.0F; int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); // 如果计算出来的容量大于阈值,则初始化阈值 if (t > threshold) threshold = tableSizeFor(t); } // 已经初始化的,如果s 大于 阈值,则进行扩容 else if (s > threshold) resize(); // 将m中的所有元素存入该实例中 for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { K key = e.getKey(); V value = e.getValue(); putVal(hash(key), key, value, false, evict); } } }
(三) 方法解析
(1) hash 函数 :
说明:存进来的key通过该函数生成hash值
// 将key生成hash值 static final int hash(Object key) { int h; // 计算hash值 :假如数组的长度是 16 ,那计算出元素在数组中的存储下标就是 hash & (16 - 1) // 也是是 hash & 1111 ,如果有两个key,其生成的hashCode分别为ABCD0000(8个16进制,32位),0ADC0000 // 将这两个hashCode(先转成二进制)和 1111按位与的话,得到的结果都是0,但是这两个hashCode相差很多,但却 // 存在数组的同一个位置上,这样会导致链表过长,而影响查询速度,所以为了减少这种情况,所以这里使用h >>> 16(无符号右移) return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
(2) getNode 函数
说明: 在HashMap中的get方法就是调用该方法用key来获取value
// 通过key获取对应存放的节点 final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; // (n - 1) & hash 该元素在table中的下标,如果获取到不为null的话。 // 获取第一个(链表的头或者红黑树的root)判断key是否一样,一样的话直接返回 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k)))) return first; // 如果不一样判断是否有下一个元素 if ((e = first.next) != null) { // 有的话判断该下标的元素是不是树节点 if (first instanceof TreeNode) // 遍历红黑树获取 return ((TreeNode<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; }
(3) putVal 函数
说明: HashMap中的put方法就是调用该方法来插入值
//添加键值对 //如果onlyIfAbsent为true的话,不改变已经存在的值 // 如果evict为false的话,说明该HashMap是刚创建的 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为null的话重新创建一个table if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; // n - 1 & hash 计算出该键值对存放的下标,如果该下标没有其他节点,则直接生成节点并存入 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { // e :下面操作如果该key已经存在,则将该key对应的节点赋值给e Node<K,V> e; K k; // 如果key已经存在并且key对应的节点是在第一个的话,则使用已经存在的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 { // 如果下标使用的是链表结构,则生成Node节点并添加到链表的尾部 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); // 如果链表长度大于8的话则转换成红黑树 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } // 如果key已经存在的话,则使用已经存在的key的节点 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // 如果key存在的话则修改值,并返回旧值 V oldValue = e.value; // 判断是否要修改 if (!onlyIfAbsent || oldValue == null) e.value = value; // 设置节点的值后回调 afterNodeAccess(e); return oldValue; } } // 修改次数 + 1 ++modCount; // 如果键值对个数超过阈值,则扩容 if (++size > threshold) resize(); // 插入节点后回调 afterNodeInsertion(evict); return null; }
(4) resize 函数
说明:每一次扩容都会对遍历所有元素然后重新进行hash
// 重新设置数组(table)的大小,其实就是重新创建一个长度更大的数组 final Node<K,V>[] resize() { // 获取旧的table Node<K,V>[] oldTab = table; // 获取旧数组的长度 int oldCap = (oldTab == null) ? 0 : oldTab.length; // 获取旧的map存储的阈值、 int oldThr = threshold; // 定义新的数组长度和新的阈值 int newCap, newThr = 0; if (oldCap > 0) { //如果旧数组的长度已经达到最大长度,则不重新创建,继续使用旧的数组 if (oldCap >= MAXIMUM_CAPACITY) { // 而阈值d 使用 int的最大值 threshold = Integer.MAX_VALUE; return oldTab; } // 新的数组长度 * 2 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) // 旧阈值 * 2 newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // initial capacity was placed in threshold // 如果旧的数组长度为0,而阈值大于0的话,那新的数组长度赋值为阈值 newCap = oldThr; else { // zero initial threshold signifies using defaults // 如果旧的数组长度为0并且阈值也是0的话,那新的数组长度为默认长度, // 阈值为默认长度乘加载因子 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数组 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 将table赋值为新的Node数组 table = newTab; // 如果旧table不为空的话,就数据移到新的table中 if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { Node<K,V> e; // 遍历旧table获取各个Node if ((e = oldTab[j]) != null) { oldTab[j] = null; // 如果该下标的元素只有一个的话(就是没有不同的key生成的hash值 // 一样而映射到数组的同一个位置而生成链表或红黑树的情况下) // 直接将该元素跟新的数组长度-1按位与生成新的下标并存入新数组中 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; // 将同一下标的元素根据(e.hash & oldCap)是否等于0进行分割,分成两个链表 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; }
总结: 个人觉得加载因子的取值对HashMap的性能有很大的影响,如果加载因子的值比较小的话,那元素冲突的几率较小,所以查询的效率较高,但是加载因子太小会导致容器空闲空间较多,而且存储元素多的话会导致容器频繁扩容, 每次扩容都会遍历所有的元素进行rehash 。如果加载因子较大的话容器中填满的元素就越多了,减少了空间的开销,但是冲突几率较高,查询性能较低。