java容器——关于HashMap

1.HashMap的数据结构：

哈希表结构（链表散列：数组+链表）实现，有数组和链表的优点，在链表长度超过8时，链表转换为红黑树。数组类型是Entry，Entry存储键值对，它包含四个字段，final K key, V value, Entry<K,V> next, int hash,可看出Entry是一个链表，数组中的每一个位置被当成一个桶，一个同放一个链表，使用拉链法（1.7之前头插，1.8尾插）解决冲突，同一个链表存哈希值相同的Entry。

2. HashMap的工作原理：

底层是hash数组和单向链表实现，数组中每个元素为链表，有Node内部类（实现Map.Entry<K,V>接口）实现，通过put,get存取。

存储对象：

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    // 键为 null 单独处理
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    // 确定桶下标
    int i = indexFor(hash, table.length);
    // 先找出是否已经存在键为 key 的键值对，如果存在的话就更新这个键值对的值为 value
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        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;
}

将K/V键值传给put()方法：1）调用hash(K)方法计算K的hash值，然后结合数组长度，计算数组下标；2）调整数组大小（当容器元素个数大于capacity*loadfactor时，容器会进行扩容2n）；3)如果K的hash值在HashMap中不存在，则执行插入，若存在，则发生碰撞，若存在且二者equals返回true，则更新键值对，若存在但是二者equals不等，则插入链表尾部或者红黑树中。

HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode() 方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。

获取对象：

获取对象时将K传给get()方法，1）调用hash(K)方法（计算K的hash值）从而获取该键值所在链表的数组下标；2）顺序遍历链表，equals()方法查找相同Node链表中K值对应的V值。

hashCode是定位的，存储位置；equals是定性的，比较二者是否相等。

3. 当两个对象的hashCode相同会发生什么？

hashCode相同不一定就是相等，所以两个对象所在数组下标相同，会发生碰撞，因为hashMap使用链表存储对象，则该Node会存储到链表中。

4. hash的实现以及原因：

JDK 1.8 中是通过hashCode()的高16位异或低16位实现的：（h=k.hashCode())^(h>>>16)，主要从速度，功效和质量来考虑的，减少系统的开销，也不会造成因为高位没有参与下标的计算从而引起的碰撞。

使用异或保证了对象的hashCode的32位值只要有一位发生改变，整个hash()返回值就会改变，尽可能减少碰撞。

5. HashMap的table容量的确定，loadFactor是什么，容量如何变化，有什么问题。

table数组大小由capacity参数确定，默认16（ArrayList默认是10）,也可以构造时传入，最大限制1<<30;

loadFactor时装填因子，用来确认table数组是否需要动态扩容，默认0.75，如当数组大小16，装填因子0.75时，threshold是12，table的实际大小超过12时就需要动态扩展。扩展是用resize()方法将table长度变为原来的两倍（16*2 而不是12*2），但是扩展会带来性能损失，因为扩容需要把oldTable的所有键值对重新插入newTable中，在性能要求高的地方这种损失是致命的。

6. HashMap的遍历方式：

主要有四种方式：

1）for-each map.keySet()--只需要K值的时候推荐使用

for(String key: map.keySet()){
    map.get(key);
}

2) for-each map.entrySet()--当需要V值的时候推荐使用

for(Map.Entry<String,String> entry:map.entrySet()){
    entry.getKey();
    entry.getValue();
}

3) for-each map.entrySet()+临时变量

Set<Map.Entry<String,String>> entrySet = map.entrySet();
    for(Map.Entry<String,String> entry: entrySet){
        entry.getKey();
        entry.getValue();
    }

4) for-each map.entrySet().iterator()

Iterator<Map.Entry<String,String>> iterator = map.entrySet().iterator();
    while(iterator.hasNext()){
        Map.Entry<String,String> entry = iterator.next();
        entry.getKey();
        entry.getValue();
    }

7. HahsMap,LinkedHashMap,TreeMap区别以及使用场景：

LinkedHashMap继承自HashMap,有快速查找的特性，保存了记录的插入顺序，内部维护一个双向链表，在用Iterator遍历时先取到的记录肯定是先插入的，比HashMap慢。

TreeMap实现SortMap接口，能够把它保存的记录根据键排序（默认按键值升序排序，也可以指定排序的比较器。

一般情况下，使用最多的是HashMap。

HashMap在Map中插入，删除和定位元素时使用；TreeMap在需要按照自然顺序或自定义顺序遍历键的情况下；LinkedHashMap在需要输出的顺序和输入的顺序相同的情况下使用。

8. HashMap和HashTable区别：

1）HashMap是线程不安全的，HashTable是线程安全的；

2）由于线程安全所以HashTable效率比不上HashMap;

3) HashMap最多只允许一条记录的键为null,允许多条记录值为null，而HashTable不允许；

4) HashMap默认大小16，HashTable为11，前者扩容时，扩大两倍，后者扩大两倍+1；

5）HashMap需要重新计算hash值，HashTable直接使用对象的hashCode。

9. java中另一个线程安全的与HashMap极其类似的类是什么，同样是线程安全，他与HashTable在线程同步上有什么区别：

1) ConcurrentHashMap类是java并发包中提供的一个线程安全且高效的HashMap实现。

2) HashTable是使用synchronize关键字加锁的原理（就是对对象加锁）；

3) 而ConcurrentHashMap在1.7中采用分段锁的方式；1.8采用CAS(无锁算法支持更高的并发度）+synchronized（在CAS操作失败是使用内置锁synchronized)。

10. HashMap和ConcurrentHashMap的区别：

ConcurrentHashMap 和 HashMap 实现上类似，最主要的差别是（JDK 1.7)ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数），理论上无太大区别，另外HashMap键值对允许有null,但是ConCurrentHashMap不允许。

11. ConcurrentHashMap比HashTable效率高的原因：

HashTable使用一把锁锁住整个链表结构，处理并发问题，多个线程竞争一把锁，容易阻塞。

ConcurrentHashMap在1.7中使用分段锁（ReentrantLock+Segment+HashEntry),相当于把一个HashMap分成多个段，每段分配一把锁，这样支持多线程访问。所力度基于Segment,包含多个HashEntry。JDK 1.8中使用CAS+synchronized+Node+红黑树。锁粒度：Node(首节点)，锁粒度降低了。

12. ConcurrentHashMap锁机制的具体分析（1.7 vs 1.8)

1.7中采用分段锁的机制，实现并发更新擦偶哦，，包含两个核心静态内部类Segement和HashEntry。

1）Segment继承ReentrantLock（重入锁）用来充当锁的角色，每个segment对象守护每个散列映射表的若干个桶；

2) HashEntry用来封装映射表中的键值对；

3）每个桶是由若干个HashEntry对象链接起来的链表

、

JDK 1.8中，采用Node+CAS+synchronized来保证并发安全。取消Segment直接用table数组存储键值对，当HashEntry对象组成的链表长度超过TREEIFY_THRESHOLD时，链表转换为红黑树，提升性能。底层变更为数组+链表+红黑树。

13. ConcurrentHashMap在JDK 1.8中，为什么使用内置锁synchronized来代替重入锁ReentrantLock？

1）粒度降低了；

2）JVM开发团队没有放弃synchronized,而且基于JVM的synchronized优化空间更大，更加自然；

3) 在大量数据操作下，对于JVM的内存压力，基于API的ReentrantLock会开销更多的内存。

14. ConcurrentHashMap简单介绍：

1）重要的常量：

private transient volatile int sizeCtl;

当为负数时，-1表示正在初始化，-N表示N-1个线程正在进行扩容；当为0时，表示table还没有初始化；党委其他正数时，表示初始化或者下一次进行扩容的大小。

2）数据结构：

Node是存储结构的基本单元，继承HashMap中的Entry，用于存储数据；TreeNode继承Node,但是数据结构换成了二叉树结构，是用黑叔的存储接哦古，用于红黑树中存储数据；TreeBin是封装TreeNode的容器，提供转换红黑树的一些条件和锁的控制。

3) 存储对象时：

1.如果没有初始化，就调用 initTable() 方法来进行初始化；
2.如果没有 hash 冲突就直接 CAS 无锁插入；
3.如果需要扩容，就先进行扩容；
4.如果存在 hash 冲突，就加锁来保证线程安全，两种情况：一种是链表形式就直接遍历到尾端插入，一种是红黑树就按照红黑树结构插入；
5.如果该链表的数量大于阀值 8，就要先转换成红黑树的结构，break 再一次进入循环
6.如果添加成功就调用 addCount() 方法统计 size，并且检查是否需要扩容。

4) 扩容方法：

transfer():默认容量16，扩容为原来的两倍。helpTransfer()调用多个工作线程一起帮助进行扩容，这样的效率就会更高。

5) 获取对象：

1. 计算 hash 值，定位到该 table 索引位置，如果是首结点符合就返回；
2.如果遇到扩容时，会调用标记正在扩容结点 ForwardingNode.find()方法，查找该结点，匹配就返回；
3.以上都不符合的话，就往下遍历结点，匹配就返回，否则最后就返回 null。

6) 并发度:

程序运行时能够同时更新ConcurrentHashMap且不产生锁竞争的最大线程数，默认16，且可以在构造函数中设置。当用户设置并发度时ConcurrentHashMap会使用大于等于该值的最小2幂指数作为实际并发度（例如用户设置并发度为17，实际并发度为32）。

参考资料：

1. https://www.jianshu.com/p/75adf47958a7 HashMap相关面试及其解答

2. https://github.com/CyC2018/CS-Notes/blob/master/notes/Java%20%E5%AE%B9%E5%99%A8.md

斌斌有礼吗

发布了25 篇原创文章 · 获赞 1 · 访问量 7526

私信关注

java容器——关于HashMap

猜你喜欢