Java集合框架详解(三) HashMap

最新推荐文章于 2022-07-31 23:43:35 发布
最新推荐文章于 2022-07-31 23:43:35 发布
阅读量262 收藏
点赞数
分类专栏： 总结 文章标签： jdk java hashmap map
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq200258/article/details/82587169
版权

今天继续对集合框架源码的学习 JDK1.8 今天学习HashMap

相关文章

HashMap

HashMap介绍

HashMap是基于哈希表的 Map 接口的实现，以Entry<k, v>键值对为单位的集合，并且同前面介绍的ArrayList和LinkedList一样，它不是线程安全的。
在JDK1.8中，HashMap加入了红黑树结构，红黑树具体我也是才学习到，所以这一次HashMap拖了很久，详细学习请往下看。

类定义

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

HashMap继承了AbstractMap

数据结构

    //数组以及链表结构
    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;
        }
    }
 interface Entry<K,V> {

        K getKey();

        V getValue();

        V setValue(V value);

        boolean equals(Object o);

        int hashCode();

        public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }

        public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getValue().compareTo(c2.getValue());
        }

        public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
        }

        public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
        }
    }

通过上述代码，能发现HashMap中有一个Node内部类，它实现了Entry接口，含有Key，Value，next属性，到这里我们慢慢可以知道，实际上Node就是HashMap的其中一个信息元素，数据均以键值对的形式保存在Node中，Node再保存到HashMap中。这些搞清楚后，下面看看类属性。

类属性


    //默认初始容量
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    //最大容量2^30
    static final int MAXIMUM_CAPACITY = 1 << 30;

    //加载因子
    //如果哈希表中的元素放得太满，就必须进行rehashing(再哈希)。再哈希使哈希表元数增倍，并将原有的对象重
    //新导入新的哈希表元中，而原始的哈希表元被删除。load factor(加载因子)决定何时要对哈希表进行再哈希
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    //链表节点转换红黑树节点的阈值8
    static final int TREEIFY_THRESHOLD = 8;

    //红黑树节点转换链表节点的阈值, 6个节点转
    static final int UNTREEIFY_THRESHOLD = 6;

    //转红黑树时, table的最小长度
    static final int MIN_TREEIFY_CAPACITY = 64;

    //保存Node<K,V>节点的数组
    transient Node<K,V>[] table;

    //由HashMap中Node组成的set
    transient Set<Map.Entry<K,V>> entrySet;

    //HashMap中元素的数量
    transient int size;

    //hashMap发生结构性变化的次数（不包括value的覆盖）
    transient int modCount;

    //HashMap 容量
    int threshold;

    //记录加载因子
    final float loadFactor;

构造方法

    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);
    }

    //返回一个比给定整数大且最接近的2的幂次方整数
    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;
    }

关于tableSizeFor(int cap)的原理

不得不说，这个算法非常巧妙，能够返回比cap大且最接近2的幂的数。

第一步： n |= n >>> 1; 也就是n变为n与n右移一位之后异或后的值，即

n: 00..01XXXXXXX

n>>>1: 00..001XXXXXX

新n： 00..011XXXXXX 到这里我们看不出什么

第二步： n |= n >>> 2; 也就是n变成n与n右移两位之后异或的值，即

n: 00..011XXXXXX

n>>>2: 00..00011XXXX

新n: 00..01111XXXX

后面相类似。到这个地方我们就能知道，算法把第一个1后面的所有位全部变成了1，最后返回n+1，即比cap大的最小二的幂

我们再看看其他构造方法

    //指定初始容量，采用0.75加载因子
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    public HashMap() {//均采用默认值
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

HashMap的一些重要方法

关于hash方法

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

整个过程本质上就是三步：

拿到key的hashCode值

将hashCode的高位参与运算，重新计算hash值

将计算出来的hash值与(table.length - 1)进行&运算

方法解读：

对于任意给定的对象，只要它的hashCode()返回值相同，那么计算得到的hash值总是相同的。我们首先想到的就是把h>ash值对table长度取模运算，这样一来，元素的分布相对来说是比较均匀的。

但是模运算消耗还是比较大的，我们知道计算机比较快的运算为位运算，因此JDK团队对取模运算进行了优化，使用上面代码2的位与运算来代替模运算。这个方法非常巧妙，它通过 “(table.length -1) & h” 来得到该对象的索引位置，这个优化是基于以下公式：x mod 2^n = x & (2^n - 1)。我们知道HashMap底层数组的长度总是2的n次方，并且取模运算为“h mod table.length”，对应上面的公式，可以得到该运算等同于“h & (table.length - 1)”。这是HashMap在速度上的优化，因为&比%具有更高的效率。

在JDK1.8的实现中，还优化了高位运算的算法，将hashCode的高16位与hashCode进行异或运算，主要是为了在table的length较小的时候，让高位也参与运算，并且不会有太大的开销。

下图是一个简单的例子，table长度为16：

hash

参考文章:Java集合：HashMap详解（JDK 1.8）

resize()

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//oldTab表示原来的HashMap数组
        int oldCap = (oldTab == null) ? 0 : oldTab.length;//oldCap表示原来的容量
        int oldThr = threshold;//表示原来的临界值
        int newCap, newThr = 0;//新容量，新临界值
        if (oldCap > 0) {//原来的HamhMapf非空，需要扩容
            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;//变为null 垃圾回收
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;//找到该结点在数组中所在位置并无冲突情况下写入，e.hash & (newCap - 1)在前面已经解释过，见hash方法的分析
                    else if (e instanceof TreeNode)//e为树型结点，说明存在以红黑树的结点变量，则调用相关红黑树方法
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order 存在冲突，并且不是红黑树类型的hash冲突，即HashMap链表的hash冲突
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            // 因为新数组的长度是原数组的2倍, newTable.length-1 比 oldTable.length-1 多oldCap, 所以 hash & (newTable.length - 1) 等价于 hash & (oldTable.length - 1) + (hash & oldCap == 0 ? 0 : oldCap)
                            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;
    }

put(K key, V value)

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    static final int hash(Object key) {
        int h;
        //使用（hashCode的值）以及（hashCode的值无符号右移16位）做异或操作
        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;
        // table是否为空或者length等于0，如果为空或为0则调用resize初始化
        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))))//判断p结点的hash和key值是否与传入的结点相同
                e = p;//如果相同，则p结点即要查找的结点，赋值给e
            else if (p instanceof TreeNode)//若原本为红黑树结点，则调用putTreeVal方法
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {// p.next为空代表不存在目标节点则新增一个节点插入链表尾部
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) //-1是因为循环是从p.next开始的
                            treeifyBin(tab, hash);//链表上结点超过TREEIFY_THRESHOLD - 1，调用方法转化为红黑树
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))//如果e结点的hash与key值都与传入的相同，则e为我们要找的结点，跳出循环
                        break;
                    p = e; //下一结点p.next
                }
            }
            //之前的代码都是在找待修改或插入的结点e，后面分析如果e不为空（即e已经找到）的结果
            if (e != null) { // 如果需要插入的元素e已经找到
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;//将该节点的value覆盖,返回oldValue
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)//操作后超过阈值则进行扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }

get(Object key)

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    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) {//first为待查结点的hash对应的位置所在的结点
            if (first.hash == hash && // 
                ((k = first.key) == key || (key != null && key.equals(k))))//如果hash值以及key都相同，说明是待查结点，无hash冲突
                return first;//返回该结点
            if ((e = first.next) != null) {//存在hash冲突，分两种情况
                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;
    }

remove(Object key)

    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }


    //  @param matchValue 为true时只有value相同时才删除，false则强制删除
    //  @param movable 如果为false则不移动其他结点，true会移动
    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) {//当hashmap数组不为空并且hash所在位置结点不为空时，说明可以该位置存在结点
            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;//当key等于传入的key，并且hash相同，说明没有hash冲突，把所在的结点传给p
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)//存在红黑树类型的冲突
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    do {//存在链表类型的hash冲突
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);//遍历数组，直到找到待删结点或者(e = e.next) != null
                }
            }
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {//如果node不为空说明已经找到了待删结点，以及判断是否强制删除，如果不强制删除则继续判断待删结点的value是否为对应node的value
                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;
    }

HashMap总结

  • HashMap(JDK1.8)使用的是数组 + 链表 + 红黑树的形式，相比于JDK1.7的数组 + 链表很大程度上提升了HashMap的性能；
  • HashMap依然不是线程安全的，在并发环境下使用HashMap会导致死循环，可以使用ConcurrenctHashMap(详情等到学习并发的时候详细分析)；
  • HashMap扩容是进行2倍扩容(正常情况下)，在创建对象的时候，由于扩容是非常消耗性能的操作，所以最好先定义好容量避免多次扩容；
  • 在HashMap所有方法中，这些可能只是冰山一角，在以后的学习中会继续对HashMap源码进行更加深刻的学习；
  • 未完待续
Crearns
关注
专栏目录
JAVA中的集合框架（Map&HashMap）
weimeig的博客
03-15 181
转帖请注明本文出自weimeig的博客（http://blog.csdn.net/weimeig/article/details/79575842），请尊重他人的辛勤劳动成果，谢谢应朋友们反馈的JAVA基础薄弱的问题，决定出一套完整的JAVA基础教程，帮助大家复习，巩固JAVA基础，今天要讲的是JAVA中的Map&amp;HashMap集合。import java.util.HashSet; im...
Java 中的集合框架之 Map接口、HashMap 类、HashTable 类、TreeMap 类（1万字超全详解）
林二月的博客
07-19 1516
接口描述Collection 接口Collection 是最基本的集合接口，一个 Collection 代表一组 Object（即 Collection 的元素）, Java不提供直接继承自 Collection的类，只提供继承自 Collection 接口的子接口(如 List和 set)。Collection 接口存储一组不唯一，无序的对象（不能通过索引来访问 Collection 集合中的对象）。List 接口。
java concurrency: ConcurrentHashMap
点缀星辰
09-04 361
引言     以前有几次碰到过一个有意思的多线程问题，当时的场景看起来比较简单。有两个线程，他们都需要写数据到统一的一个数据结构里，因为这两个线程是相互独立的，在他们执行的过程中我们将每个线程的一组名值对输出。当时觉得这不过是一个很简单的问题，我们可以用一个HashTable或者HashMap就可以了。我们可以保证两个线程访问数据的key是不同的，看起来应该不会存在多线程访问的冲突。实际运行...
Map 综述（三）：彻头彻尾理解 ConcurrentHashMap
热门推荐
Rico's Blogs
05-27 13万+
ConcurrentHashMap是J.U.C的重要成员，它是HashMap的一个线程安全的版本。在默认理想状态下，ConcurrentHashMap可以支持16个线程执行并发写操作及任意数量线程的读操作。本文将结合Java内存模型和JDK源代码，剖析其高并发的具体实现机制，包括在JDK中的定义和结构、并发存取、重哈希和跨段操作，并着重剖析了ConcurrentHashMap读操作不需要加锁的内在奥秘和原理。
ConcurrentHashMap 详解
ljz2016的博客
11-07 3900
以hashmap这一篇为基础，分析一下ConcurrentHashMap。 hashmap是线程不安全的，而hashtable性能低下，所以concurrentHashMap应运而生。 ConcurrentHashMap使用锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。有些方法需要跨段，比如size()...
Java集合框架详解
03-29
Java集合框架是Java语言提供的用于存储数据和操作数据的集合类库。在Java集合框架中，Map接口的实现类广泛用于存储键值对数据结构。主要实现类包括HashMap、Hashtable、LinkedHashMap和TreeMap。 1. HashMap：它...
java集合框架详解
08-31
Java集合框架是Java编程语言中用于存储和管理对象的核心组件。它提供了一组接口和类，使得开发者能够高效地组织数据，无论是简单的数据集还是复杂的对象结构。本文将深入探讨Java集合框架的各个方面，包括其概述、...
基于Java中最常用的集合类框架之HashMap(详解)
08-28
"基于Java中最常用的集合类框架之HashMap详解" Java中的HashMap是一种常用的集合类框架，它基于哈希表的Map接口实现，提供了所有可选的映射操作。HashMap存储的是对的映射，允许多个null值和一个null键，但它不保证...
Java集合之HashMap用法详解
08-30
HashMap是Java集合框架中最常用的Map集合，它的键值对在存储时要根据键的哈希码来确定值放在哪里。HashMap中的键对象必须重写Object的hashCode()方法和equals()方法，以确保键的唯一性。 HashMap的基本操作 HashMap...
Java集合框架源码分析之LinkedHashMap详解
08-29
Java集合框架源码分析之LinkedHashMap详解 Java集合框架中的LinkedHashMap是HashMap的子类，它继承了HashMap的存储结构，但引入了一个双向链表的头结点，将所有put到LinkedHashMap的节点连接成一个双向循环链表，...
深入源码学习1.8的ConcurrentHashMap（二）
令走天下的博客
05-23 179
一、ConcurrentHashMap的使用方法实现 1、get操作 get方法比较简单，给定一个key来确定value的时候，必须满足两个条件 key相同 hash值相同，对于节点可能在链表或树上的情况，需要分别去查找。 2、put操作 put方法就是，沿用HashMap的put方法的思想，根据hash值计算这个新插入的点在table中的位置i，如果i位置是空的，直接放进去，否则进行判断，...
ConcurrentHashMap
Lucifer ZHAO
05-30 8600
ConcurrentHashMap和HashMap原理基本类似，只是在HashMap的基础上需要支持并发操作，保证多线程情况下对HashMap操作的安全性。当某个线程对集合内的元素进行数据操作时，会锁定这个元素，如果其他线程操作的数据hash得到相同的位置，就必须等到这个线程释放锁之后才能进行操作。
ConcurrentHashMap简介
gulanga5的博客
03-07 5万+
一、jdk1.8之前的数据结构： 1.默认情况下会有16个区段 Segment数组 Segment[16] 2.每次每个区段Segment中会保存若干个散列桶，每次散列桶长度扩容成2^n次方的长度。 多个散列桶相连就构成了散列表。 3.存入元素： key带入到hashcode方法众获得hashcode值，然后把hashcode值带入到散列算法中获取segment的下标(区段编号)，再根据key带入到定义好的函数中获取Segment对象中散列桶的下标。 如果此位置有元素就构成链表(JDK1.8及以后会
ConcurrentHashMap原理详解(太细了)
qq_42068856的博客
07-31 6万+
和HashMap一样，是一个存放键值对的容器。使用hash算法来获取值的地址，因此时间复杂度是O(1)。查询非常快。同时，是线程安全的HashMap。专门用于多线程环境。做插入操作时，首先进入乐观锁，然后，在乐观锁中判断容器是否初始化，如果没初始化则初始化容器，如果已经初始化，则判断该hash位置的节点是否为空，如果为空，则通过CAS操作进行插入。如果该节点不为空，再判断容器是否在扩容中，如果在扩容，则帮助其扩容。如果没有扩容，则进行最后一步，先加锁，然后找到hash。......
Java集合框架：HashMap
weixin_33966095的博客
03-17 601
Java集合框架概述   Java集合框架无论是在工作、学习、面试中都会经常涉及到，相信各位也并不陌生，其强大也不用多说，博主最近翻阅java集合框架的源码以及搜索一些相关资料整理出Java集合框架的系列。一方面是做一个总结，方便以后查阅，另一方面希望各位小伙伴能够提出不足之处，我会及时更新修改。   博主从网上抠了一张图，觉得画得...
浅析JAVA集合框架之HashMap
秀强的专栏
12-01 1368
数据结构
ConcurrentHashMap分析
简单世界的博客
08-24 1973
ConcurrentHashMap源码解析
ConcurrentHashMap详解
qq_42337039的博客
10-10 995
存储结构 ConcurrentHashMap由多个Segment组合，而每一个Segment是一个类似于HashMap的结构，所以每一个HashMap的内部可以进行扩容，但是Segment的个数一旦初始化就不能改变，默认segment的个数是16个，可以认为ConcurrentHashMap默认支持最多16个线程并发 初始化 通过ConcurrentHashMap的无参构造函数探寻初始化过程 /** * Creates a new, empty map with a default ini
Java集合框架详解：HashMap与线程安全
"Java集合教程涵盖了线程不安全和安全的集合类，包括HashMap、HashTable、TreeMap、ArrayList、Vector、LinkedList、Set等。文章详细讨论了HashMap的特点，如其在不同JDK版本下的实现方式，以及容量和扩容策略。线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值