HashMap一文通
来源:互联网 发布:樱井知香番号大全 编辑:程序博客网 时间:2024/06/15 04:55
HashMap一文通
标签: JAVA COLLECTIONS 源码
为什么CSDN的md样式如此丑陋???
推荐看官看 https://www.zybuluo.com/kiraSally/note/819843
1.什么是HashMap
- 基于哈希表的Map接口的非同步实现
- 此实现提供所有可选的映射操作,并允许使用null值和null键
- 此类不保证映射顺序
- 此实现假定哈希函数将元素适当分布在各桶之间,为读取操作提供稳定性能
- 迭代时间与实例容量(桶的数量)及其大小(键-值映射关系数)成正比
- 本版本为JDK1.7,
此链接为JDK1.8版本(加班赶点中)
2.HashMap的数据结构
- 类定义
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
- 重要全局变量 - 链表散列的数据结构(数组+链表【冲突解决方案-封闭寻址方法】)
备注:建议直接看英文注释,更加清晰明了//The default initial capacity - MUST be a power of two.static final int DEFAULT_INITIAL_CAPACITY = 16;//The maximum capacity - MUST be a power of two <= 1<<30.static final int MAXIMUM_CAPACITY = 1 << 30;//The load factor used when none specified in constructor.static final float DEFAULT_LOAD_FACTOR = 0.75f;//The table, resized as necessary. Length MUST Always be a power of two.transient Entry<K,V>[] table;//The number of key-value mappings contained in this map.transient int size;//The next size value at which to resize (capacity * load factor).int threshold;//The load factor for the hash table.final float loadFactor;/** * The number of times this HashMap has been structurally modified * Structural modifications are those that change the number of mappings in * the HashMap or otherwise modify its internal structure (e.g., * rehash). This field is used to make iterators on Collection-views of * the HashMap fail-fast. (See ConcurrentModificationException). */transient int modCount;
- 构造器
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; //阈值为容量*负载因子和最大容量+1之间的最小值 以此值作为容量翻倍的依据(不能超过最大容量) threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1); //初始化一个2次幂的Entry类型数组 一个桶对应一个Entry对象 table = new Entry[capacity]; useAltHashing = sun.misc.VM.isBooted() && (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD); init();}
- 数组内元素的链表结构
/** * 静态类 默认实现内部Entry接口 (接口中可定义内部接口-Map.Entry接口为Map的内部接口) * PS:JDK8中引入default,作用为在接口中定义默认方法实现 */static class Entry<K,V> implements Map.Entry<K,V> { final K key;//key具有引用不可变特性 V value; Entry<K,V> next;//next指向下一个:单向链表,头插入 final int hash; ……}
3.HashMap的存储
- put方法解析
/** * @return key不存在返回null,否则返回旧值 */public V put(K key, V value) { //其允许存放null的key和null的value //当其key为null时,调用putForNullKey方法,放入到table[0]的这个位置(null键只有一个) if (key == null) return putForNullKey(value); //通过调用hash方法对key进行哈希,得到哈希之后的数值 //其目的是为了尽可能的让键值对可以分不到不同的桶中 int hash = hash(key); //根据上一步骤中求出的hash得到在数组中是索引i int i = indexFor(hash, table.length); //如果i处的Entry不为null,则通过其next指针不断遍历e元素的下一个元素。 for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k;//使用临时变量k主要用于e.key的赋值,意义有限 //hash一致 && (key引用相同 或 key字符串比较相同) 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;//若key不存在则返回null}
- hash方法解析
//JDK1.7final int hash(Object k) { int h = 0; if (useAltHashing) { if (k instanceof String) { return sun.misc.Hashing.stringHash32((String) k); } h = hashSeed; } //异或就是两个数的二进制形式,按位对比,相同取0,不同取一 //此算法加入了高位计算,防止低位不变,高位变化时,造成的 hash 冲突 h ^= k.hashCode(); h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4);}//JDK1.8 扰动函数 -> 散列值优化函数static final int hash(Object key) { int h; //把一个数右移16位即丢弃低16为,就是任何小于2^16的数,右移16后结果都为0 //2的16次方再右移刚好就是1 同时int最大值为32位 //任何一个数,与0按位异或的结果都是这个数本身 //为indexFor做准备 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}
- indexFor方法解析
/** * Int范围(2^32)从-2147483648到2147483648,加起来大概40亿空间,内存不能直接读取 * 用之前还要先做对数组的长度取模运算,得到的余数才能用来访问数组下标 * @Param h 根据hash方法得到h * @Param length 一定是2次幂 */static int indexFor(int h, int length) { //2次幂-1 返回的结果的二进制为永远是都是1 比如 15 -> 1111 (16 -> 10000) //与运算 只有 1 & 1 = 1 正好相当于一个“低位掩码” //如果length-1中某一位为0,则不论h中对应位的数字为几,对应位结果都是0,这样就让两个h取到同一个结果,hash冲突 //同时这个操作可以保证索引不会大于数组的大小(见开头的描述) return h & (length-1);}
- addEntry方法解析
//该方法为包访问 package java.util(本包私有性高于子类)void addEntry(int hash, K key, V value, int bucketIndex) { //当前容量超过阈值 && 当前坐标数组非空 //有个优雅的设计在于,若bucketIndex处没有Entry对象,那么新添加的entry对象指向null,从而就不会有链了 if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length);//容量扩容一倍 hash = (null != key) ? hash(key) : 0;//hash重新计算 bucketIndex = indexFor(hash, table.length);//index重新计算 } createEntry(hash, key, value, bucketIndex);//新增Entry元素到数组的制定下标位置}//该方法为包访问 package java.utilvoid createEntry(int hash, K key, V value, int bucketIndex) { // 获取指定 bucketIndex 索引处的 Entry Entry<K,V> e = table[bucketIndex]; // 将新创建的 Entry 放入 bucketIndex 索引处,并让新的 Entry 指向原来的 Entry // 形成链表,新加入的放入链表头部,最先加入的放入尾部 table[bucketIndex] = new Entry<>(hash, key, value, e); size++;}
关于indexFor和hash方法的进一步解读
- hashCode返回的-2147483648到2147483648的int值,加起来大概40亿的映射空间。只要哈希函数映射比较均匀松散,一般很难出现碰撞
key.hashCode()
- 但问题是40亿长度数组,内存放不下,该散列值不能直接拿来用。用之前必须先对数组长度取模运算,得到的余数才能来访问数组下标
indexFor()
长度取2的整次幂,而length-1时正好相当于一个低位掩码。与操作的结果就是散列的高位全部归零,只保留低位值,用作下标访问
10100101 11000100 00100101& 00000000 00000000 00001111 00000000 00000000 00000101 //高位全部归零,只保留末四位
但问题是,无论散列值再松散,但只取最后几位,碰撞也很严重。更要命的是如果散列本身做的不好,分布上成等差数列,就会出现规律性重复,这时候就需要扰动函数进行打散优化.
- 扰动函数生效:
右位移16位(32位一半),让高半区和低半区做异或,目的是混合原始哈希码的高位和低位,以此来加大低位的随机性。而且混合后的低位包含高位的部分特征,这样高位的信息也变相保留下来。 - 当长度非2次幂(最后一位永远是0),进行与运算(只有都为1得1,否则为0),会造成最后一位永远是0,那最后一位就无法使用,导致(1)空间的巨大浪费。同时可使用的位置比原数组长度小很多,(2)进一步增加了碰撞的几率。
- hashCode返回的-2147483648到2147483648的int值,加起来大概40亿的映射空间。只要哈希函数映射比较均匀松散,一般很难出现碰撞
归纳
- 存储时,根据hash算法决定其在数组中的存储位置,再根据equals方法决定其在该数组位置上的链表中的存储位置;同时HashMap会根据当前bucket的占用情况自动调整容量(超过loadFacotr则resize为原来的2倍)
- 读取时,根据hash算法找到其在数组中的存储位置,再根据equals方法从该位置上的链表中取出该Entry。在产生碰撞的情况下,进行get时,两步的时间复杂度是O(1)+O(n)。1.8使用红黑树(O(1)+O(logn))
4.HashMap的Resize
性能参数
- initialCapacity 初始容量 默认16
- loadFactor(负载因子) : 衡量的是一个散列表的空间的使用程度,负载因子越大表示散列表的装填程度越高,反之愈小。对于使用链表法的散列表来说,查找一个元素的平均时间是 O(1+a),因此如果负载因子越大,对空间的利用更充分,然而后果是查找效率的降低;如果负载因子太小,那么散列表的数据将过于稀疏,对空间造成严重浪费。默认的的负载因子 0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时, resize后的HashMap 容量是容量的两倍
resize方法解析
/** * Rehashes the contents of this map into a new array with a * larger capacity. This method is called automatically when the * number of keys in this map reaches its threshold. * 目的:通过增加内部数组的长度的方式,从而保证链表中只保留很少的Entry对象,从而降低put(),remove()和 get()方法的执行时间 * 注意:如果两个Entry对象的键的哈希值不一样,但它们之前在同一个桶上,那么在调整以后,并不能保证它们依然在同一个桶上 */void resize(int newCapacity) { Entry[] oldTable = table;//使用临时拷贝,保证当前数据时效性(参见JAVA的`观察者`模式实现) int oldCapacity = oldTable.length; if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; } //实例化一个newCapacity容量的新数组 Entry[] newTable = new Entry[newCapacity]; boolean oldAltHashing = useAltHashing; useAltHashing |= sun.misc.VM.isBooted() && (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD); boolean rehash = oldAltHashing ^ useAltHashing; transfer(newTable, rehash);//遍历旧数组对新数组赋值 table = newTable;//引用替换 threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//重新计算阈值}
- transfer方法解析
/** * Transfers all entries from current table to newTable. */void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; //注意:如果在新表的数组索引位置相同,则链表元素会倒置,也就是先插入最近的 for (Entry<K,V> e : table) { while(null != e) { Entry<K,V> next = e.next; if (rehash) { e.hash = null == e.key ? 0 : hash(e.key);//重新计算hash } int i = indexFor(e.hash, newCapacity); //注意:多线程环境可能由于执行次序非有序造成next引用变更赋值出错导致环形链接出现,从而造成死循环 e.next = newTable[i]; newTable[i] = e; e = next; } }}
5.Fail-Fast机制
错误机制
- 当使用迭代器的过程中有其他线程修改了map,将抛出
ConcurrentModificationException
- 当使用迭代器的过程中有其他线程修改了map,将抛出
源码实现
transient int modCount;//修改计数 put、remove或clear时mount++ clear时清空HashIterator() { expectedModCount = modCount; if (size > 0) { Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; }}final Entry<K,V> nextEntry() { //期望变更数量不匹配 if (modCount != expectedModCount) throw new ConcurrentModificationException();
- HashMap的remove方法实现
public V remove(Object key) { Entry<K,V> e = removeEntryForKey(key); return (e == null ? null : e.value);}
- HashMap.KeySet的remove方法实现
public boolean remove(Object o) { return HashMap.this.removeEntryForKey(o) != null;}
- HashMap.HashIterator的remove方法实现
public void remove() { if (current == null) throw new IllegalStateException(); if (modCount != expectedModCount) throw new ConcurrentModificationException(); Object k = current.key; current = null; HashMap.this.removeEntryForKey(k); //重要操作:迭代器中删除时同步了expectedModCount值与modCount相同 expectedModCount = modCount;}
- remove方法解析
/** * Removes and returns the entry associated with the specified key * in the HashMap. Returns null if the HashMap contains no mapping * for this key. */final Entry<K,V> removeEntryForKey(Object key) { int hash = (key == null) ? 0 : hash(key); int i = indexFor(hash, table.length); Entry<K,V> prev = table[i];//用于记录该key的前一个元素(默认先从队首开始) Entry<K,V> e = prev;//从队首开始往队尾遍历 //遍历key所在链表 while (e != null) { Entry<K,V> next = e.next; Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { modCount++;//remove属于结构性改造,modCount计数+1 size--;//当前Map的有效元素数量-1 if (prev == e) table[i] = next;//若当前key正好位于队首,则队首指向next else prev.next = next;//若当前key不位于队首,则该key之前的元素的next指向该key的下一个元素 e.recordRemoval(this);//钩子方法 return e; } //继续往队尾找 prev = e;//指向当前循环元素的上一个元素 e = next;//指向下一次循环元素 } return e;}
- 迭代推荐方式
Map map = new HashMap();Iterator iter = map.entrySet().iterator();while (iter.hasNext()) { Map.Entry entry = (Map.Entry) iter.next(); Object key = entry.getKey(); Object val = entry.getValue();}
6.常见面试题
1.什么时候会使用HashMap?他有什么特点?
- 基于Map接口实现的Key-Value容器,允许null值,同时非有序,非同步。
2.你知道HashMap的工作原理吗?
- 参见
归纳
- 在Java 8中,如果一个bucket中碰撞冲突的元素超过某个限制(默认是8),则使用红黑树来替换链表,从而提高速度
3.你知道get和put的原理吗?equals()和hashCode()的都有什么作用?
- 通过对key的hashCode()进行hashing,并计算下标( n-1 & hash),从而获得buckets的位置。如果产生碰撞,则利用key.equals()方法去链表或树中去查找对应的节点
4.你知道hash的实现吗?为什么要这样实现?
- 在Java 1.8的实现中,是通过hashCode()的高16位异或低16位实现的:(h = k.hashCode()) ^ (h >>> 16),主要是从速度、功效、质量来考虑的,这么做可以在bucket的n比较小的时候,也能保证考虑到高低bit都参与到hash的计算中,同时不会有太大的开销。
- 使用hash还有一个好处就是 尽可能确保每个链表中的长度一致
5. 如果HashMap的大小超过了负载因子(load factor)定义的容量,怎么办?
- 如果超过了负载因子(默认0.75),则会重新resize一个原来长度两倍的HashMap,并且重新调用hash方法;同时此时很可能出现一系列问题:参见
问题6
6. 你了解重新调整HashMap大小存在什么问题吗?
- 当数据过多时,很可能出现性能瓶颈(包括rehash时间)
使用HashMap时一定保证数量有限- 多线程情况下可能产生条件竞竞争从而造成死循环(具体表现在CPU接近100%)。多线程同时试着调整大小,可能导致存储在链表中的元素的次序颠倒,因为移动到新的bucket位置的时候,HashMap并不会将元素放在链表的尾部,而是放在头部,这是为了避免尾部遍历。具体死循环代码参见
transfer(newTable)
多线程环境下推荐使用ConcurrentHashMap
7. 为什么String, Interger这样的wrapper类适合作为键?
- class具有final属性,同时重写equals()和hashCode()
- hashCode变动会导致读取失效
- final同时保证线程安全
对象推荐重写equals和hashCode方法,主要用于Map存取时的对比,同时有利于减少碰撞
8.我们可以使用自定义的对象作为键吗?
- 这是前一个问题的延伸。当然你可能使用任何对象作为键,只要它遵守了equals()和hashCode()方法的定义规则,并且当对象插入到Map中之后将不会再改变了。如果这个自定义对象时不可变的,那么它已经满足了作为键的条件,因为当它创建之后就已经不能改变了。
9.如何对HashMap进行排序?
- 转换:Map -> Set -> LinkedList(存key)
- 排序:LinkedList自行sort
- 存储:存入有序LinkedHashMap
10.HashMap的remove陷阱?
- 通过Iterator方式可正确遍历完成remove操作
- 直接调用list的remove方法就会抛异常
11.为什么只允许通过iterator进行remove操作?
- HashMap和keySet的remove方法都可以通过传递key参数删除任意的元素
- 而iterator只能删除当前元素(current),一旦删除的元素是iterator对象中next所正在引用的,如果没有通过modCount、 expectedModCount的比较实现快速失败抛出异常,下次循环该元素将成为current指向,此时iterator就遍历了一个已移除的过期数据
- 之所以推荐迭代器remove的根本原因在于只有迭代器的remove方法中实现了变更时于modCount的同步工作
expectedModCount = modCount;
12.如果是遍历过程中增加或修改数据呢?
- 增加或修改数据只能通过Map的put方法实现,在遍历过程中修改数据可以,但如果增加新key就会在下次循环时抛异常,因为在添加新key时modCount也会自增(迭代器只实现了remove方法也是原因之一)
阅读全文
0 0
- HashMap一文通
- HashMap
- HashMap
- HashMap
- HashMap
- HashMap
- HashMap
- HashMap
- HashMap
- HashMap
- HashMap
- HashMap
- hashmap
- HashMap
- HashMap
- HashMap
- hashmap
- HashMap
- 解决在Android中给Button设置Padding无效的问题
- OC语言学习14-JSON数据解析
- 数据结构之栈
- 2017.07.20回顾 xgboost安装 xgboost抄作业
- Java8 并发之原子变量与ConcurrentMap
- HashMap一文通
- 九、excel导入数据查重问题
- NOIP 2013 Senior 4
- 模拟实现部分字符串函数
- ios-图片概述
- Java类加载器总结
- Http中Cookie详解以及Android中操作Cookie
- Alerter华丽的消息推送栏
- 全面的IE兼容性调试问题