常考集合面试题之Map(四)

java基础之集合(Collection单列集合和Map双列集合) 目录 集合体系图 一.Collection集合 1.1List集合 1.1.1List集合的实现类:ArrayList集合 1.1.2LinkedList集合 1.2Set集合 1.2.1Set集合的特点 1.2.2哈希值 1.2.3HashSet集合 1.2.4TreeSet集合 二.Map集合 2.1Map集合的概述与特点 2.1.1Map集合概述 2.1.2Map集合的特点 2.1.3Map集合的一些常用方法: 2.2Map集合的遍历方式(方式一) ... 阅读详情

Map文章目录

 

一、Map接口

1.1、说一下 HashMap 的实现原理?

  • HashMap概述: HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作,并允许使用null值和null键。此类不保证映射的顺序,特别是它不保证该顺序恒久不变。
  • HashMap的数据结构: 在Java编程语言中,最基本的结构就是两种,一个是数组,另外一个是模拟指针(引用),所有的数据结构都可以用这两个基本结构来构造的,HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构,即数组和链表的结合体。
  • HashMap 基于 Hash 算法实现的
  1. 当我们往Hashmap中put元素时,利用key的hashCode重新hash计算
    出当前对象的元素在数组中的下标
  2. 存储时,如果出现hash值相同的key,此时有两种情况。(1)如果key相同,则覆盖原始值;(2)如果key不同(出现冲突),则将当前的key-value放入链表中
  3. 获取时,直接找到hash值对应的下标,在进一步判断key是否相同,从而找到对应值。
  4. 理解了以上过程就不难明白HashMap是如何解决hash冲突的问题,核心就是使用了数组的存储方式,然后将冲突的key的对象放入链表中,一旦发现冲突就在链表中做进一步的对比。

需要注意Jdk 1.8中对HashMap的实现做了优化,当链表中的节点数据超过八个
之后,该链表会转为红黑树来提高查询效率,从原来的O(n)到O(logn)

1.2、HashMap在JDK1.7和JDK1.8中有哪些不同?HashMap的底层实现

  1. 1.8用了红黑树
  2. 1.7插入的时候用了头插法,1.8插入的时候用了尾插法
  3. 1.7会rehash,1.8没有这份代码逻辑
  4. 1.8的hash算法时高低16位做异或运算,1.7的时候会进行4次无符号右移,5个与运算(具体原因:JDK7的Hash算法⽐JDK8中的更复杂,Hash算法越复杂,⽣成的hashcode则更散列,那么hashmap中的元素则更散列,更散列则hashmap的查询性能更好,JDK7中没有红⿊树,所以只能优化Hash算法使得元素更散列,⽽JDK8中增加了红⿊树,查询性能得到了保障,所以可以简化⼀下Hash算法,毕竟Hash算法越复杂就越消耗CPU)
  5. JDK8中扩容的条件和JDK7中不⼀样,除开判断size是否⼤于阈值之外,JDK7中还判断了tab[i]是否为空,不为空的时候才会进⾏扩容,⽽JDK8中则没有该条件了
  6. JDK8中还多了⼀个API:putIfAbsent(key,value)
  7. JDK7和JDK8扩容过程中转移元素的逻辑不⼀样,JDK7是每次转移⼀个元素,JDK8是先算出来当前位置上哪些元素在新数组的低位上,哪些在新数组的⾼位上,然后在⼀次性转移

1.3、HashMap的put方法的具体流程?

在这里插入图片描述

  1. 根据key生成hashcode
  2. 判断当前HashMap对象中的数组是否为空,如果为空则初始化该数组
  3. 1.7的时候会进行4次无符号右移,5个与运算,1.8会进行高16位和低16位进行逻辑与运算,算出hashcode基于当前数组对应的数组下标i
  4. 判断数组的第i个位置的元素(tab[i])是否为空
    a. 如果为空,则将key,value封装为Node对象赋值给tab[i]
    b. 如果不为空:
    i. 如果put⽅法传⼊进来的key等于tab[i].key,那么证明存在相同的key
    ii. 如果不等于tab[i].key,则:
    1. 如果tab[i]的类型是TreeNode,则表示数组的第i位置上是⼀颗红⿊树,那么将key和value插⼊到红⿊树中,并且在插⼊之前会判断在红⿊树中是否存在相同的key
    2. 如果tab[i]的类型不是TreeNode,则表示数组的第i位置上是⼀个链表,那么遍历链表寻找是否存在相同的key,并且在遍历的过程中会对链表中的结点数进⾏计数,当遍历到最后⼀个结点时,会将key,value封装为Node插⼊到链表的尾部,同时判断在插⼊新结点之前的链表结点个数是不是⼤于等于8,且数组的长度大于64,如果是,则将链表改为红⿊树。
    iii. 如果上述步骤中发现存在相同的key,则根据onlyIfAbsent标记来判断是否需要更新value值,然后返回oldValue
  5. modCount++
  6. HashMap的元素个数size加1
  7. 如果size⼤于扩容的阈值,则进⾏扩容
//node数组
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;
    }
}
//put的过程
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
//1.7的hash
  final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
}
//1.8的hash
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        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 {
            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))))
                    break;
                p = e;
            }
        }
        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;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105

1.4、HashMap的get方法的具体流程?

  1. 根据key⽣成hashcode
  2. 如果数组为空,则直接返回空
  3. 如果数组不为空,则利⽤hashcode和数组⻓度通过逻辑与操作算出key所对应的数组下标i
  4. 如果数组的第i个位置上没有元素,则直接返回空
  5. 如果数组的第1个位上的元素的key等于get⽅法所传进来的key,则返回该元素,并获取该元素的value
  6. 如果不等于则判断该元素还有没有下⼀个元素,如果没有,返回空
  7. 如果有则判断该元素的类型是链表结点还是红⿊树结点
    a. 如果是链表则遍历链表
    b. 如果是红⿊树则遍历红⿊树
  8. 找到即返回元素,没找到的则返回空
//get方法
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//getNode方法
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((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;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

1.5、HashMap的扩容操作是怎么实现的?

①.在jdk1.8中,resize方法是在hashmap中的键值对大于阀值时或者初始化时,就调用resize方法进行扩容;
②.每次扩展的时候,都是扩展2倍;
③.扩展后Node对象的位置要么在原位置,要么移动到原偏移量两倍的位置。在putVal()中,我们看到在这个函数里面使用到了2次resize()方法,resize()方法表示的在进行第一次初始化时会对其进行扩容,或者当该数组的实际大小大于其临界值值(第一次为12),这个时候在扩容的同时也会伴随的桶上面的元素进行重新分发,这也是JDK1.8版本的一个优化的地方,在1.7中,扩容之后需要重新去计算其Hash值,根据Hash值对其进行分发,但在1.8版本中,则是根据在同一个桶的位置中进行判断(e.hash & oldCap)是否为0,重新进行hash分配后,该元素的位置要么停留在原始位置,要么移动到原始位置+增加的数组大小这个位置上

 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) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        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) {
                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 {
                                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;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73

1.6、HashMap是怎么解决哈希冲突的?

  1. 使用链地址法(使用散列表)来链接拥有相同hash值的数据;
  2. 使用2次扰动函数(hash函数)来降低哈希冲突的概率,使得数据分布更平
    均;
  3. 引入红黑树进一步降低遍历的时间复杂度,使得遍历更快;

1.7、能否使用任何类作为 Map 的 key?

可以使用任何类作为 Map 的 key,然而在使用之前,需要考虑以下几点:

  • 如果类重写了 equals() 方法,也应该重写 hashCode() 方法。
  • 类的所有实例需要遵循与 equals() 和 hashCode() 相关的规则。
  • 如果一个类没有使用 equals(),不应该在 hashCode() 中使用它。
  • 用户自定义 Key 类最佳实践是使之为不可变的,这样 hashCode() 值可以被缓存起来,拥有更好的性能。不可变的类也可以确保 hashCode()和 equals() 在未来不会改变,这样就会解决与可变相关的问题了。

1.8、为什么HashMap中String、Integer这样的包装类适合作为K?

String、Integer等包装类的特性能够保证Hash值的不可更改性和计算准确性,能够有效的减少Hash碰撞的几率

  1. 都是final类型,即不可变性,保证key的不可更改性,不会存在获取hash值不同的情况
  2. 内部已重写了 equals() 、 hashCode() 等方法,遵守了HashMap内部的规范(不清楚可以去上面看看putValue的过程),不容易出现Hash值计算错误的情况;

1.9、如果使用Object作为HashMap的Key,应该怎么办呢?

重写 hashCode() 和 equals() 方法

  1. 重写 hashCode() 是因为需要计算存储数据的存储位置,需要注意不要试图从散列码计算中排除掉一个对象的关键部分来提高性能,这样虽然能更快但可能会导致更多的Hash碰撞;
  2. 重写 equals() 方法,需要遵守自反性、对称性、传递性、一致性以及对于任何非null的引用值x,x.equals(null)

1.10、HashMap为什么不直接使用hashCode()处理后的哈希值直接作为table的下标?

hashCode() 方法返回的是int整数类型,其范围为-(2 ^ 31)~(2 ^ 31 - 1),约有40亿个映射空间,而HashMap的容量范围是在16(初始化默认值)~2 ^30,HashMap通常情况下是取不到最大值的,并且设备上也难以提供这么多的存储空间,从而导致通过 hashCode() 计算出的哈希值可能不在数组大小范围内,进而无法匹配存储位置;
所以:

  1. HashMap自己实现了自己的 hash() 方法,通过两次扰动使得它自己的哈希值高低位自行进行异或运算,降低哈希碰撞概率也使得数据分布更平均;
  2. 在保证数组长度为2的幂次方的时候,使用 hash() 运算之后的值与运算(&)(数组长度 - 1)来获取数组下标的方式进行存储,这样一来是比取余操作更加有效率,二来也是因为只有当数组长度为2的幂次方时,h&(length-1)才等价于h%length,三来解决了“哈希值与数组大小范围不匹配”的问题;

1.11、HashMap 的长度为什么是2的幂次方

为了能让 HashMap 存取高效,尽量较少碰撞,也就是要尽量把数据分配均匀,每个链表/红黑树长度大致相同。这个实现就是把数据存到哪个链表/红黑树中的算法。

这个算法应该如何设计呢?
我们首先可能会想到采用%取余的操作来实现。但是,重点来了:“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作(也就是说hash%length==hash&(length-1)的前提是 length 是2的 n 次方;)。” 并且 采用二进制位操作 &,相对于%能够提高运算效率,这就解释了 HashMap的长度为什么是2的幂次方。

那为什么是两次扰动呢?

  • 这样就是加大哈希值低位的随机性,使得分布更均匀,从而提高对应数组存储下标位置的随机性&均匀性,最终减少Hash冲突,两次就够了,已经达到了高位低位同时参与运算的目的;

1.12、HashMap 与 HashTable 有什么区别?

  1. 线程安全: HashMap 是非线程安全的,HashTable 是线程安全的;HashTable 内部的方法基本都经过 synchronized 修饰。(如果你要保证线程安全的话就使用 ConcurrentHashMap 吧!);
  2. 效率: 因为线程安全的问题,HashMap 要比 HashTable 效率高一点。另外,HashTable 基本被淘汰,不要在代码中使用它;
  3. 对Null key 和Null value的支持: HashMap 中,null 可以作为键,这样的键只有一个,可以有一个或多个键所对应的值为 null。但是在HashTable 中 put 进的键值只要有一个 null,直接抛NullPointerException。
  4. 初始容量大小和每次扩充容量大小的不同 : ①创建时如果不指定容量初始值,Hashtable 默认的初始大小为11,之后每次扩充,容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充,容量变为原来的2倍。②创建时如果给定了容量初始值,那么 Hashtable 会直接使用你给定的大小,而 HashMap 会将其扩充为2的幂次方大小。也就是说 HashMap 总是使用2的幂作为哈希表的大小,后面会介绍到为什么是2的幂次方。
  5. 底层数据结构: JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为8)时,将链表转化为红黑树,以减少搜索时间。Hashtable 没有这样的机制。
  6. 推荐使用:在 Hashtable 的类注释可以看到,Hashtable 是保留类不建议使用,推荐在单线程环境下使用 HashMap 替代,如果需要多线程使用则用 ConcurrentHashMap 替代。

1.13、如何决定使用 HashMap 还是TreeMap?

对于在Map中插入、删除和定位元素这类操作,HashMap是最好的选择。然而,假如你需要对一个有序的key集合进行遍历,TreeMap是更好的选择。基于你的collection的大小,也许向HashMap中添加元素会更快,将map换为TreeMap进行有序key的遍历。

1.14、HashMap 和 ConcurrentHashMap 的区别

  1. ConcurrentHashMap对整个桶数组进行了分割分段(Segment),然后在每一个分段上都用lock锁进行保护,相对于HashTable的synchronized锁的粒度更精细了一些,并发性能更好,而HashMap没有锁机制,不是线程安全的。(JDK1.8之后ConcurrentHashMap启用了一种全新的方式实现,利用CAS算法。)
  2. HashMap的键值对允许有null,但是ConCurrentHashMap都不允许。

1.15、ConcurrentHashMap 和 Hashtable 的区别?

ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。

  • 底层数据结构 : JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现,JDK1.8 采用的数据结构跟HashMap1.8的结构一样,数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 数组+链表 的形式,数组是 HashMap 的主体,链表则是主要为了解决哈希冲突而存在的;
  • 实现线程安全的方式(重要) :
    ① 在JDK1.7的时候,ConcurrentHashMap(分段锁) 对整个桶数组进行了分割分段(Segment),每一把锁只锁容器其中一部分数据,多线程访问容器里不同数据段的数据,就不会存在锁竞争,提高并发访问率。(默认分配16个Segment,比Hashtable效率提高16倍。) 到了 JDK1.8 的时候已经摒弃了Segment的概念,而是直接用Node 数组+链表+红黑树的数据结构来实现,并发控制使用synchronized 和 CAS 来操作。(JDK1.6以后 对 synchronized锁做了很多优化) 整个看起来就像是优化过且线程安全的 HashMap,虽然在JDK1.8中还能看到 Segment 的数据结构,但是已经简化了属性,只是为了兼容旧版本;
    ②Hashtable(同一把锁) :使用 synchronized 来保证线程安全,效率非常低下。当一个线程访问同步方法时,其他线程也访问同步方法,可能会进入阻塞或轮询状态,如使用 put 添加元素,另一个线程不能使用 put 添加元素,也不能使用 get,竞争会越来越激烈效率越低。

两者的对比图:
HashTable:
在这里插入图片描述
JDK1.7的ConcurrentHashMap:
在这里插入图片描述
JDK1.8的ConcurrentHashMap(TreeBin: 红黑二叉树节点 Node: 链表节点):
在这里插入图片描述

ConcurrentHashMap 结合了 HashMap 和 HashTable 二者的优势。HashMap 没有考虑同步,HashTable 考虑了同步的问题。但是 HashTable 在每次同步执行时都要锁住整个结构。 ConcurrentHashMap 锁的方式是稍微细粒度的。

1.16、ConcurrentHashMap 底层具体实现知道吗?实现原理是什么?

JDK1.7
首先将数据分为一段一段的存储,然后给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据时,其他段的数据也能被其他线程访问。
在JDK1.7中,ConcurrentHashMap采用Segment + HashEntry的方式进行实现,结构如下:
一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和HashMap类似,是一种数组和链表结构,一个 Segment 包含一个 HashEntry数组,每个 HashEntry 是一个链表结构的元素,每个 Segment 守护着一个HashEntry数组里的元素,当对 HashEntry 数组的数据进行修改时,必须首先获得对应的 Segment的锁。
在这里插入图片描述

  1. 该类包含两个静态内部类 HashEntry 和 Segment ;前者用来封装映射表的键值对,后者用来充当锁的角色;
  2. Segment 是一种可重入的锁 ReentrantLock,每个 Segment 守护一个HashEntry 数组里得元素,当对 HashEntry 数组的数据进行修改时,必须首先获得对应的 Segment 锁。

JDK1.8
在JDK1.8中,放弃了Segment臃肿的设计,取而代之的是采用Node + CAS+ Synchronized来保证并发安全进行实现,synchronized只锁定当前链表或红黑二叉树的首节点,这样只要hash不冲突,就不会产生并发,效率又提升N倍。
结构如下:
在这里插入图片描述
附加源码,有需要的可以看看
插入元素过程(建议去看看源码):
如果相应位置的Node还没有初始化,则调用CAS插入相应的数据;

1 else if ((f = tabAt(tab, i = (n ‐ 1) & hash)) == null) {
2  if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
3  break; // no lock when adding to empty bin
4 }
如果相应位置的Node不为空,且当前该节点不处于移动状态,则对该节点加
synchronized锁,如果该节点的hash不小于0,则遍历链表更新节点或插入新
节点;
 if (fh >= 0) {
  binCount = 1;
  for (Node<K,V> e = f;; ++binCount) {
  K ek;
  if (e.hash == hash &&
  ((ek = e.key) == key ||
  (ek != null && key.equals(ek)))) {
  oldVal = e.val;
  if (!onlyIfAbsent)
  e.val = value;
  break;
  }
  Node<K,V> pred = e;
  if ((e = e.next) == null) {
  pred.next = new Node<K,V>(hash, key, value, null);
  break;
  }
  }
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  1. 如果该节点是TreeBin类型的节点,说明是红黑树结构,则通过putTreeVal方法往红黑树中插入节点;如果binCount不为0,说明put操作对数据产生了影响,如果当前链表的个数达到8个,则通过treeifyBin方法转化为红黑树,如果oldVal不为空,说明是一次更新操作,没有对元素个数产生影响,则直接返回旧值;
  2. 如果插入的是一个新节点,则执行addCount()方法尝试更新元素个数baseCount;
Halcon 20.11在WPF中的交互式绘图:完整实现矩形ROI的创建、拖动与坐标获取 本文详细介绍了如何在WPF框架下利用Halcon 20.11实现交互式矩形ROI的创建、拖动与坐标获取。通过HDrawingObject和HSmartWindowControlWPF控件,开发者可以高效构建机器视觉应用,提升项目实战中的开发效率。文章涵盖环境配置、事件处理、坐标获取及性能优化等关键内容。 阅读详情

相关推荐

基于结构的虚拟筛选模型 gnina 从源码编译

所需要的软件安装包: 安装 CUDA 装的时候看着点,第二个要你装驱动的选择,回答N,不装。 sudo sh cuda_10.0.130_410.48_linux.run sudo vim ~/.bashrc 在 ~/.bashrc 文件最后加上 export PATH=/usr/bin:/usr/local/cuda-10.0/bin${PATH} export LD_LIBRARY_PATH=/usr/local/cuda-10.0/lib64:${LD_LIBRARY_PATH} source ~

周迪新的博客 3190

HashMap中获取键和值的两种方法

HashMap中获取键和值的两种方法 package cn.itcast.Day10; import java.util.HashMap; import java.util.Map; import java.util.Set; import static cn.itcast.Day10.ChangeParase.show2; public class HashMap_one { ...

执迷于技术和算法,让我们一起成长 2350

相机图像质量研究(15)常见问题总结:光学结构对成像的影响--暗角

老式相机的暗角往往比较明显,周围一圈能够明显感觉到亮度下降的很多,当然有些电源模仿手持相机的摄影效果,也能看到周围明显的亮度下降。一、

xiaoshixiu的专栏 1125

Java-ConcurrentHashMap

第一次添加元素的时候,默认初期长度为16,当往map中继续添加元素的时候,通过hash值跟数组长度取与来决定放在数组的哪个位置,如果出现放在同一个位置的时候,优先以链表的形式存放,在同一个位置的个数又达到了8个以上,如果数组的长度还小于64的时候,则会扩容数组。通过扩容数组的方式来把这些节点给分散开。接下来遍历链表的后续节点,没添加一个元素的时候,都会通过判断hash值来决定是放在根节点的左节点还是有节点,如果左/右节点不为空,则继续以左/右节点来重复判断,直到左/右节点为空,则添加到左/右位置。

ALONG的博客 943

别再问“这游戏啥引擎做的”了,手把手教你用SteamDB一键查询(附实战案例)

本文详细介绍了如何使用SteamDB一键查询游戏引擎信息,包括Unity 3D、Unreal Engine等热门引擎的识别方法。通过实战案例和高级查询技巧,帮助玩家快速获取游戏技术底细,优化游戏体验和兼容性分析。

weixin_31412781的博客 837

从 Product Master 视角理解 Configurable Products

摘要:SAP S/4HANA中的可配置产品(Configurable Products)通过集中管理产品变体解决主数据膨胀问题。以汽车和服务器为例,销售端显示为单一产品,生产端则处理多维度组合。核心机制包括:1)使用KMAT物料类型或Configurable标记;2)通过特征(characteristics)定义可选项;3)用分类(class)组织特征;4)配置档案(configuration profile)控制业务逻辑。这种设计将客户选择与主数据解耦,避免为每个组合创建独立物料,同时支持销售配置、生产B

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 86

HashMap源码详解(一)

HashMap HashMap是一个用于存储K-V的集合。每个键值对也叫做Entry对象。 HashMap是一个table数组,数组的每一个Entry元素都是链表的头结点。 HashMap的链表中,每个Entry元素通过new指针指向下一个Entry元素。 两个hashcode相同时,它们所对应的bucket相同,这个时候HashMap会使用链表或者红黑树来进行存储。 调用get()方法,当hashcode相同的时候,HashMap会使用键对象的hashcode找到bucket位置,然后调用keys.

Decadent丶沉沦の博客 513

OpenHarmony开发一个App,安装到BearPi-HM Micro开发板

建议先阅读我们这篇,这里面详细介绍了,以及hap包安装的全过程。本篇是介绍如何开发一个App,然后安装到开发板上,比如hap包,无法安装等问题。

Halifax 1030

HashMap

hashmap 是一个entry对象的数组 数组中的每一个entry元素 又是一个链表的头节点 HashMap 是数组 + 链表 数据结构 默认初始化容量 16 ,因子 0.75 元素12个 然后rehash 每次2 的次方 时间复杂度 0(1) 链表 0(n) jdk1.8 阈值 0(lgn) ...

有趣的难受 819

华为OD新系统机试真题 - 配置操作失败数量统计

华为OD机试新系统 4月8号【配置操作失败数量统计】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试真题【配置操作失败数量统计】。

qq_45776114的博客 1165

3D打印机控制系统设计:基于MATLAB的3D打印机运动学建模、轨迹规划和控制

控制实现:在控制实现中,需要将轨迹规划的结果转化为实际的控制指令,控制3D打印机按照规划的轨迹进行运动。3D打印机的运动学建模:3D打印机的运动学建模是指将3D打印机的机械结构、传动系统和运动控制部件等抽象成数学模型,以便于进行控制系统的设计和分析。轨迹规划:轨迹规划是指根据3D模型的几何形状和打印机的运动学模型,计算出打印机需要执行的运动轨迹,以便于实现所需的打印效果。控制实现:控制实现是指将轨迹规划的结果转化为控制指令,控制3D打印机按照规划的轨迹进行运动。

走向CTO的路上... 2475

HasMap 底层源码分析

目录   一、什么是哈希表   二、HashMap实现原理   三、为何HashMap的数组长度一定是2的次幂?   四、重写equals方法需同时重写hashCode方法 一、什么是哈希表   在讨论哈希表之前,我们先大概了解下其他数据结构在新增,查找等基础操作执行性能   数组:采用一段连续的存储单元来存储数据。对于指定下标的查找,时间复杂度为O(1);通过给定值进行查找,需要遍...

程序员Feri 606

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

常考集合面试题(一)

集合面试题目录一、集合容器概述1、什么是集合2、集合的特点3、集合和数组的区别4、使用集合框架的好处5、常用的集合类有哪些?6、List,Set,Map三者的区别?List、Set、Map 是否继承自 Collection 接口?List、Map、Set 三个接口存取元素时,各有什么特点?7、集合框架底层数据结构8、哪些集合类是线程安全的?9、Java集合的快速失败机制 “fail-fast”?10、 fail-safe(安全失败)是什么?11.fail-fast(快速失败)和fail-safe(安全失败

zhouhengzhe的博客 1579

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Java中集合常考面试题总结

使用分段锁(Segment)实现,将整个Map分为多个部分,每个部分独立加锁,允许多线程同时访问不同的部分,提高并发性能。该方法可以对List集合进行排序,使用默认的自然排序方式进行排序,也可以通过传入Comparator对象来实现自定义排序。该方法可以对数组进行排序,使用默认的自然排序方式进行排序,也可以通过传入Comparator对象来实现自定义排序。这些排序方法可以根据具体的需求选择使用,可以根据元素的自然顺序进行排序,也可以根据自定义的比较规则进行排序。添加和删除操作需要移动元素,效率较低。

qq_58417838的博客 571

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Java集合高频面试题(最新版)

Java集合 刚刚经历过秋招,看了大量的面经,顺便将常见的Java集合常考知识点总结了一下,并根据被问到的频率大致做了一个标注。一颗星表示知识点需要了解,被问到的频率不高,面试时起码能说个差不多。两颗星表示被问到的频率较高或对理解Java有着重要的作用,建议熟练掌握。三颗星表示被问到的频率非常高,建议深入理解并熟练掌握其相关知识,方便面试时拓展(方便装逼),给面试官留下个好印象。 文章目录Java集合常用的集合类有哪些? ***List,Set,Map三者的区别? *****常用集合框架底层数据结构**

zydybaby的博客 5680

Java集合面试题看这篇就够了

备战实习,会定期的总结常考的面试题,大家一起加油! ???? 往期文章: 【面试题】计算机网络篇-10道常见面试题p1 【面试题】JVM篇-10道常见面试题p1 【面试题】Java并发篇-10道常见面试题p1 【面试题】Java基础篇-常见面试题总结p1 【面试题】Java基础篇-常见面试题总结p2 【面试题】MySQL常见面试题合集 【面试题】Java基础篇-常见面试题总结p3 参考文章: https://blog.youkuaiyun.com/qq_45966440/category_10889559.

小皮皮LL的博客 2万+

4.Java集合(Collection)高频面试题

Hash,一般翻译为“散列”,也有直接音译为“哈希”的,就是把任意长度的输入通过散列算法,变换成固定长度的输出,该输出就是散列值(哈希值);这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,所以不可能从散列值来唯一的确定输入值简单的说:就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数所有散列函数都有如下一个基本特性:根据同一散列函数计算出的散列值如果不同,那么输入值肯定也不同。但是,根据同一散列函数计算出的散列值如果相同,输入值不一定相同。

相互学习 共同进步 1110

java Map集合的详情

package com.day12.json; import org.junit.Test; import java.util.*; /** * Author: Json * Date: 2021/9/27 **/ public class JsonTest { public static void main(String[] args) { System.out.println("map集合的使用"); // map // |-- .

Json的知识梦工厂 218

Java 集合面试题真实场景还原

Arrays.asList转换list之后,如果修改了数组的内容,list会受影响,因为它的底层使用的Arrays类中的一个内部类ArrayList来构造的集合,在这个集合的构造器中,把我们传入的这个集合进行了包装而已,最终指向的都是同一个内存地址。list用了toArray转数组后,如果修改了list内容,数组不会影响,当调用了toArray以后,在底层是它是进行了数组的拷贝,跟原来的元素就没啥关系了,所以即使list修改了以后,数组也不受影响。比如原来的顺序是AB,扩容后的顺序是BA,线程二执行结束。

Go_ahead_forever的博客 1358

Python常考基础面试题

Python基础面试题 1、 Python 数据结构有哪些 2、Python 中列表和元组的区别是什么?元组是不是真的不可变? 3、什么是生成器和迭代器?它们之间有什么区别? 迭代器 生成器 4、什么是闭包?装饰器又是什么?装饰器有什么作用?你用过装饰器吗?请写一个装饰器的例子 5、什么是匿名函数,用匿名函数有什么好处? 6、如何提高 Python 的运行效

努力让自己发光,对的人才能迎着光而来 4万+

2025年Unity最新面试题 - 持续更新 - 渲染方向 - 贴图、纹理、材质基础知识常考

2025年Unity最新面试题 - 持续更新 - 渲染方向 - 贴图、纹理、材质基础知识常考

程序员 - 阿布拉 679

【面试八股|Java集合】Java集合常考面试题详解

【面试八股|Java集合】Java集合常考面试题详解

2303_80850235的博客 964

常考集合面试题-List接口(二)

1、List接口 1.1、迭代器 Iterator 是什么? 1.2、Iterator 怎么使用?有什么特点? 1.3、如何边遍历边移除Collection 中的元素? 1.4、Iterator 和 ListIterator 有什么区别? 1.5、遍历一个 List 有哪些不同的方式?每种方法的实现原理是什么?Java 中 List 遍历的最佳实践是什么? 1.6、说一下 ArrayList 的优缺点 1.7、如何实现数组和 List 之间的转换? 1.8、ArrayList 和 LinkedList 的区

zhouhengzhe的博客 1655

常考集合面试题之Set-Queue(三)

一、Set接口 1.1、说一下 HashSet 的实现原理? 1.2、HashSet如何检查重复? 1.3、HashSet是如何保证数据不可重复的? 1.4、HashSet与HashMap的区别 二、Queue 1.1、BlockingQueue是什么? 1.2、在 Queue 中 poll()和remove()有什么区别? ...

zhouhengzhe的博客 1862

java集合面试题总结

集合在我们的项目中,无论大小,都是必不可少的,所以面试的频率也挺高的,这里进行下总结。 java中集合间关系图: 从图中可以看到Collection接口继承于Iterator接口(map系列的集合没有继承它),而list集合与set集合都继承于Collection接口,实现Iterator接口的类可以拥有增强for循环(即foreach循环),也必须提供一个名为iterator()的方法,方法返回值为iterator,所以list集合跟set集合都有foreach循环,而map集合没有。 Iterato

m0_61083409的博客 125
上一篇: 手撕SpringMVC简单版
下一篇: 极验验证(滑动验证)的使用
爱玛士
博客等级 码龄7年 720粉丝 253原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值