Java集合总结

于 2024-09-01 21:02:05 发布
阅读量663 收藏 23
点赞数 20
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81579342/article/details/141683462
版权

1、什么是集合

Java中的集合（Collections）框架是一个非常重要的部分，它提供了一套设计良好的支持对一组对象进行操作的接口和类。这些接口和类位于java.util包中，使得我们可以以统一和灵活的方式处理对象集合。

集合体系

注释：
1.Collection接口是单列集合（一次只能添加一个数据），Map接口是双列集合（一次能添加一对数据 --- 键-值）

2.List系列的集合添加的元素是有序、可重复、有索引的（这里的有序是指存入和取出数据时的位置是相同的）

3.Set系列的集合添加的元素是无序、不重复、无索引的

2、Collection集合

Collection的基本方法

Collection
返回值类型方法名作用
booleanadd（E e）将指定元素添加到集合中
voidclear（）清空集合所有元素
booleanremove（E e）将指定元素从集合中删除
booleancontains（Object obj）判断集合中是否存在指定元素
booleanisEmpty（）判断当前集合是否为空
intSize（）得到集合当前元素的个数

 Collection遍历方式

由于Collection集合是单列集合的顶级父类因此Collection的遍历方法在它子类中都是可以使用的

（1）迭代器遍历(iterator)

Collection集合获得iterator的方法

方法名作用
Iterator<E>  iterator()返回迭代器对象，并默认指向0索引

     Iterator类的常用方法

返回值类型方法名作用
booleanHasNext()判断当前位置是否为空，如果有元素返回ture，否则返回false
Enext返回当前位置的元素，并将迭代器对象向后移
voidremove删除当前所指向集合的元素

注意：

若出现NoSuchElementException说明迭代器已指向集合最后一个元素的后面无法返回元素

在程序一次运行过程中迭代器遍历完毕后，指向元素不会复原

在一次循环中尽量不要出现俩次以上的next方法

迭代器在遍历过程中不能用集合的增删方法，但如果要在遍历中删除元素可以在循环遍历的过程中调用迭代器的删除（remove）方法

格式：

1、用Collection系列的集合调用iterator方法得到集合的迭代器对象

2、利用迭代器的hasNext方法作为while循环的条件，在每个循环中调用迭代器的next方法让迭代器返回当前的元素并将迭代器指向下一个元素

public static void main(String[] args)
{
//创建一个ArrayList集合
Collection<String> myCollection = new ArrayList<>();

//Collection的添加元素的方法
myCollection.add("A");
myCollection.add("B");
myCollection.add("C");
myCollection.add("D");

//创建一个迭代器，并用while循环遍历数据
Iterator<String> myiterator = myCollection.iterator();

while(myiterator.hasNext())
        {
            System.out.println(myiterator.next());
        }
//结果：A B C D
}

在有迭代器遍历时删除元素

public static void main(String[] args)
{
//创建一个ArrayList集合
Collection<String> myCollection = new ArrayList<>();

//Collection的添加元素的方法
myCollection.add("A");
myCollection.add("B");
myCollection.add("C");
myCollection.add("D");

//创建一个迭代器，并用while循环遍历数据
Iterator<String> myiterator = myCollection.iterator();

while(myiterator.hasNext())
        {
        String a = myiterator.next();
            if(a.equals("D")){
            myiterator.remove();
            }else{
                   System.out.println(a);
                  }
        }
//结果：A B C 
}

（2）增强for遍历

格式：

for(元素数据类型  元素名  ：  集合名){}

例：

public static void main(String[] args){
//创建集合
Collection<String> list = new ArrayList<>();
//添加元素
list.add("A");
list.add("B");
list.add("C");
list.add("D");
//遍历数据
for(String s : list){
 System.out.println(s);
}
//结果：A B C D
}

（3）Lambda表达式遍历

格式：

集合名.forEach(匿名内部类){}

例：

public static void main(String[] args){

//创建集合
Collection<String> list = new ArrayList<>();
//添加元素
list.add("A");
list.add("B");
list.add("C");
list.add("D");
//--------------------------------------------
list.forEach(new Consumer<String>(){
public void accept(String s){
System.out.println(s);
}
                                    });
//--------------------------------------------
//可简化为一下式子
list.forEach(s->System.out.println(s));
//结果 A B C D
}

3、List集合

List继承与Collection拥有Collection中的全部方法也有自己特有的方法。

List集合方法：

List
返回值类型方法名作用
voidadd(int  index ,  E  element)将指定元素添加到指定位置
Eremove(int  index)删除指定位置的元素，并返回
Eset(int  index , E  element)修改指定位置元素，并返回修改后的元素
Eget(int  index)返回指定位置的元素

List的遍历方式

1.迭代器遍历
public static void main(String[] args){


        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");

        Iterator<String> iterator =  list.iterator();
        while(iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
        //结果 A B C D
    }
2.列表迭代器遍历
ListIterator类

允许双向遍历列表（即可以向前也可以向后遍历），还可以修改遍历中的元素

方法介绍：

返回值类型方法名作用
voidadd(E e)将指定元素添加到集合中
booleanhasNext( )判断集合中是否存在元素，有返回ture否则返回false
booleanhasPrevious( )在以正向遍历列表时，如果迭代器之后还有元素返回ture，否则返回false
Enext( )将迭代器移到下一个位置，并返回元素
intnextIndex( )返回迭代器当前位置下一个元素的索引
Eprevious( )返回迭代器当前位置之后元素的索引
intpreviousIndex( )返回迭代器当前位置前一个元素的索引
voidremove( )从列表中删除由next或previous返回的最后一个元素 
voidset( )从列表中修改由next或previous返回的最后一个元素 

在遍历中增删元素

public static void main(String[] args){


        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");

        //得到listiterator迭代器
        ListIterator<String> listIterator = list.listIterator();

        while(listIterator.hasNext()){
            String s = listIterator.next();

        if(s.equals("B")) listIterator.remove();
        if(s.equals("C")) listIterator.add("T");
        }
        System.out.println(list);
        //结果 A C T D
    }

3.增强for遍历
public static void main(String[] args){


        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");

        for(String s : list){
            System.out.println(s);
        }
        //结果 A B C D
    }
4.Lambda表达式遍历
public static void main(String[] args){


        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");

        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //结果 A B C D
    }
5.普通for遍历
public static void main(String[] args){


        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");

        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //结果 A B C D
    }

List接口的实现类

（1）Array List集合

ArrayList集合的底层原理：

      ArrayList集合的底层原理是数组这意味着它使用连续的内存空间来存储元素

调用无参构造创建集合

  1. 在Java 1.6及之前版本中，使用无参构造函数创建的ArrayList，其底层数组会有一个默认的初始容量，通常是10。但请注意，随着Java版本的更新，这一行为可能会有所变化。
  2. 在Java 1.7和1.8及更高版本中，使用无参构造函数创建的ArrayList，其底层数组初始时是一个空数组（即长度为0）。只有在添加第一个元素时，才会根据需要进行扩容，通常扩容到10个元素的空间。

调用带参构造创建数组

如果在创建ArrayList时，通过带有初始容量参数的构造函数指定了初始容量，那么底层数组的大小就会直接被初始化为该容量值。例如，new ArrayList<>(100)会创建一个初始容量为100的ArrayList。

ArrayList的构造方法：

方法名作用
ArrayList( )空参
ArrayList(Collection<? extends E> c)

创建一个指定的Collection的元素的列表

ArrayList(int  initalCapacity)创建一个指定长度的列表

ArrayList的常用方法

返回值类型方法名作用
booleanadd(E  e)将指定元素添加到集合的尾部
voidadd(int  index , E  e)将指定元素插入列表的指定位置
voidclear( )移除列表中的所有元素
booleancontains(Object  o)如果列表中有指定元素返回ture，否则返回false
Eget(int index)返回列表中指定位置的元素
booleanisEmpty( )判断集合是否为空，如果为空返回ture，否则返回false
booleanremove(Object  o)删除指定元素
Eset(int  index , E  e)修改指定位置的元素
intsize( )得到列表的元素个数

public static void main(String[] args){


        ArrayList<String> myArrayList = new ArrayList<>();

        //添加元素
        myArrayList.add("A");
        myArrayList.add("B");
        myArrayList.add("C");
        myArrayList.add("D");
        myArrayList.add("E");

        //得到集合中的元素个数
        int i = myArrayList.size();
        System.out.println(i);

        //添加元素到指定位置
        myArrayList.add(5,"F");
        System.out.println(myArrayList);

        //判断集合中是否有指定元素
        boolean s = myArrayList.contains("C");
        System.out.println(s);

        //返回列表中指定位置的元素
        String e = myArrayList.get(2);
        System.out.println(e);

        //修改指定元素
        myArrayList.set(4,"G");
        System.out.println(myArrayList);

        //删除指定元素
        myArrayList.remove("A");
        System.out.println(myArrayList);

        //移除集合中的所有元素
        myArrayList.clear();
        //判断集合是否为空
        System.out.println(myArrayList.isEmpty());

    }

结果：

（2）LinkedList集合

LinedList集合的底层是双向链表特点是查询慢，增删快

常用方法：

返回中类型方法名作用
voidaddFirst(E  e)在列表头插入新的指定元素
voidaddlast(E  e)在列表尾插入新的指定元素
EgetFirst( )返回第一个元素
Egetlast( )返回最后一个元素
EremoveFirst( )删除头元素，并返回
Eremovelast( )删除尾元素，并返回

4、Set集合

set集合的特点：

1.无序：元素的存取顺序不一致

2.不重复：集合中的元素都不相同

3.无索引：集合无法通过索引来找元素，所有不能用for循环来遍历

set集合的方法上基本与Collection的API一致

Set接口的实现类

（1）HashSet

特点：无序、不重复、无索引

底层是哈希表，具有快速插入、查找、及增删的操作

底层原理：

1.一开始在底层会创建一个长度为16的，默认加载因为0，75的数组

2.根据元素的哈希值根数组的长度计算出应存入的位置

3.判断当前的位置是否为null，如果是直接存入

4.如果当前位置不为null，表示有元素，则调用equals方法比较属性值

5.如果一致：不存入            不一致：存入数组，形成链表

在JDK8前：新元素存入数组，老元素和新元素形成链表

在JDK8后：新元素直接与老元素形成链表

public static void main(String[] args){

        //创建集合
        HashSet<String> myHashSetset = new HashSet<>();

        //添加元素
        myHashSetset.add("A");
        myHashSetset.add("B");
        myHashSetset.add("D");
        myHashSetset.add("C");

        System.out.println(myHashSetset);

        //添加重复元素
        myHashSetset.add("A");
        System.out.println(myHashSetset);

    }

结果：

（2）LinkedHashSet

特点：有序、不重复、无索引

底层原理：底层是哈希表，但多用了一个双向链表的机制记录存储的顺序

public static void main(String[] args){

        //创建集合
        HashSet<String> myHashSetset = new HashSet<>();

        //添加元素
        myHashSetset.add("A");
        myHashSetset.add("B");
        myHashSetset.add("D");
        myHashSetset.add("C");

        System.out.println(myHashSetset);

        //添加重复元素
        myHashSetset.add("A");
        System.out.println(myHashSetset);

    }

结果：

由于有序性输出的顺序与输入的顺序相同

（3）TreeSet

特点：可排序、无索引、不重复

可排序：按照元素的默认规则（从小到大）排序

TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查都较好

TreeSet集合默认的排序规则

对于数值类型：Integer、Double,默认按照从小到大进行排序

对于字符、字符串类型：按照字符的ASCll码表的数字升序进行排列

补： "abc"  "aaaa" 像这样的字符串类型比大小时是用一一比较的方式而不是用每个字符的ASCll码的总和来计算

5、Map集合

Map的概念

Java中的Map集合是一种将键（Key）映射到值（Value）的对象，它可以存储键值对，其中每个键最多只能映射到一个值。Map接口的实现（如HashMap, TreeMap, HashTable等）提供了存储和操作键值对的不同机制。Map接口不是java.util.Collection接口的子接口，因此Map接口的实现并不支持Collection接口中定义的任何集合视图。

特点：

1.双列集合一次需要存一对数据，分别为键和值

2.键不能重复，值可以

3.键和值是一一对应的，每一个键只能找到自己对应的值

Map的基本方法

返回值类型方法名作用
Vput(K key , V value)添加元素
Vremove(Object key)根据键删除键值对元素
voidclear( )移除所有的键值对元素
booleancontainsKey(Object key)判断集合是否存在指定的键
booleancontainsValue(Object value)判断集合是否存在指定的值
booleanisEmpty( )判断集合是否为空
intsize( )返回集合的长度

注意：

put方法细节

1.在添加数据时，如果要添加数据的键中本身不存在元素，那么将对象添加到Map集合的列表中并返回null

2.如果要添加数据的键中本身存在元素，那么新添加的对象的值会覆盖原本此键上的值并返回原本的值

Map集合的遍历方式

1.用键找值

public static void main(String[] args){

        //创建Map集合的对象
        Map<String,String> map = new HashMap<>();

        //添加元素
        map.put("A","AAA");
        map.put("B","BBB");
        map.put("C","CCC");

        //遍历
        //将map集合的所有键放到一个单列集合中
        Set<String> keys = map.keySet();
        //遍历单列集合
        for(String key : keys){
            String value = map.get(key);
            System.out.println(key + " = " + value);
        }
    }

结果：

2.用值找键

public static void main(String[] args){

        //创建Map集合的对象
        Map<String,String> map = new HashMap<>();

        //添加元素
        map.put("A","AAA");
        map.put("B","BBB");
        map.put("C","CCC");

        //遍历
        //通过entrySet方法得到所有键值对对象
        Set<Map.Entry<String , String>> entries = map.entrySet();

        for(Map.Entry<String,String> entry : entries){
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+" = "+value);
        }
    }

结果：

Map的实现类

（1）HashMap

没有额外的特有方法，直接使用Map的方法

特点是由键决定的：无序、不重复、无索引

底层原理和HashSet一样是哈希表

依赖HashCode方法和equals方法保证键的唯一

如果键存储的是自定义对象，需要重写hashCode和equals方法，而如果是值则不用

（2）LindedHashMap

特点是由键决定的：有序、不重复、无索引

原理：底层是哈希表，在每个键值对元素又额外的多了一个双链表记录存储的顺序

主要特性

  1. 有序性：LinkedHashMap通过维护一个双向链表来记录元素的插入顺序或访问顺序（基于配置）。默认情况下，它按照元素的插入顺序进行迭代，但可以通过构造函数参数来指定是否按访问顺序（即最近访问的元素会移到链表的末尾）进行迭代。
  2. 快速访问：与HashMap一样，LinkedHashMap保持了较快的查找、插入和删除操作的时间复杂度O(1)。
  3. 可预测的迭代顺序：由于维护了链表结构，LinkedHashMap的迭代顺序是稳定的，可以根据需要选择插入顺序或访问顺序进行迭代。

应用场景

实现简单的缓存机制：通过设置accessOrder为true，可以实现LRU（最近最少使用）缓存。当缓存达到一定大小时，可以自动删除最久未使用的元素。

需要保持元素顺序的场景：例如在处理JSON数据时保持字段顺序，或者在需要按照特定顺序输出元素时，LinkedHashMap非常有用。

   优缺点优点：

  1. 可以保持元素的插入顺序或访问顺序。
  2. 查找、插入和删除操作的时间复杂度较低。
  3. 相比普通的HashMap，LinkedHashMap需要额外的内存来维护链表结构，因此会占用更多的内存空间。
  4. 在插入和删除元素时，相对于普通的HashMap，性能略低。

public static void main(String[] args) {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        map.put(1, "one");
        map.put(2, "two");
        map.put(3, "three");

        // 按插入顺序输出
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }

        // 访问一下元素
        map.get(2);

        // 再次按插入顺序输出（如果未设置accessOrder为true）
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
    }

（3）TreeMap

TreeMap 是 Java 集合框架中的一个类，它实现了 NavigableMap 接口，是基于红黑树（Red-Black Tree）数据结构实现的。红黑树是一种自平衡的二叉搜索树，它能够保证在插入、删除和查找等操作中的时间复杂度为 O(log n)。

主要特点

  1. 有序性：TreeMap 中的元素按照键的自然顺序（即实现 Comparable 接口）或通过提供的 Comparator 进行排序。这意味着 TreeMap 能够以排序的方式存储键值对，并提供与排序相关的操作。
  2. 动态更新：支持动态插入、删除和修改键值对操作，而且这些操作会保持元素的有序性。
  3. 范围查询：提供了一系列的方法来支持范围查询，如 headMap、tailMap 和 subMap 等，这些方法可以根据指定的范围获取子映射。
  4. 不允许空键：TreeMap 不允许存储 null 键，否则会抛出 NullPointerException，但允许值为 null。
  5. 线程不安全：与 HashMap 类似，TreeMap 不是线程安全的。如果需要在多线程环境中使用，可以使用 Collections.synchronizedSortedMap 方法获得一个同步的 TreeMap，或者使用 ConcurrentSkipListMap。

应用场景

  • 当需要按照键的顺序访问和处理数据时，可以使用 TreeMap 来存储键值对，并利用排序特性方便地进行相关操作。
  • TreeMap 提供了一系列的范围查询方法，适合用于需要根据键的范围来查询和操作数据的场景。
  • TreeMap 结构适合存储时间轴数据，因为时间是有序的。
  • TreeMap 可以用于实现基于 LRU（最近最少使用）算法的缓存，通过自定义比较器将访问顺序作为键的排序依据。

2301_81579342
关注
  • 20
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java集合的括号_Java集合总结
weixin_30842027的博客
02-12 1848
集合集合的特点：元素类型可以不同、集合长度可变、空间不固定集合长度：.size() 获取size属性的长度数组长度：.length()格式：ArrayList list = new ArrayList();System.out.println(list .size());list.get(i) :下标 通过集合下标获取集合中每个值​ for (int i = 0; i < list.size...
Java集合图解总结
qq_43975081的博客
11-26 1065
Java集合图解总结 JavaJava集合图解总结
java集合超详解
热门推荐
feiyan的博客
08-03 45万+
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ ArrayList 接口...
Java集合知识总结
独上高楼，望尽天涯路。
03-03 4449
深刻剖析Java集合：数据结构、概念； 集合结构图 Collection：List、Set，Map：HashMap、TreeMap；List：ArrayList、LinkedList；Set：HashSet、TreeSet； 具体实现的过程和包含的各种方法（添加、删除、修改、查询）以及源码分析。
Java集合总结，详细且易懂
WgRui的博客
09-01 4万+
深入浅出
Java集合总结大全--史上最强
程序员小哲的博客
11-22 1万+
Java集合总结大全List接口Set接口Map接口ArrayList、LinkedList和Vector的区别HashMap和HashTable的区别List、Set、Map三者的区别 List接口 有序、不唯一。 ArrayList Vector（线程安全） LinkedList Set接口 无序、不可重复 HashSet LinkedHashSet TreeSet Map接口 不能包含重复的键、每个键最多只能映射到一个值 Hashtable（线程安全） LinkedHashMap
java集合总结使用场景
酒城的博客
10-06 1096
集合总结使用场景 在开发中选择什么集合实现类，主要取决于业务操作的特点，然后根据集合实现类特性进行选择： 先判断存储的类型（一组对象（单一）或一组键值对（双列）） 一组对象（单列）：Collection 接口 允许重复值：List 增删多：LinkedList（底层是一个双向链表） 改查多：ArrayList（底层是一个数组） 线程安全：Vector ：底层是一个数组 不允许重复值：Set 无序：HashSet：底层是HashMap，维护一个（数组 + 链表 + 红黑树） 排序：TreeSet:
集合知识点总结（java）
一枚数学专业的小码农的博客
07-10 6182
集合的比较全面的总结
Java集合框架总结
ThinkWon的博客
08-08 6万+
简介 集合框架：用于存储数据的容器。 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。 任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。 接口：表示集合的抽象数据类型。接口允许我们操作集合时不必关注具体实现，从而达到“多态”。在面向对象编程语言中，接口通常用来形成规范。 实现：集合接口的具体实现，是重用性很高的数据结构。 算法：在一个实现了某个集合框架中的接口的...
java集合总结副本共19页.pdf.zip
10-30
这个“java集合总结副本共19页.pdf.zip”压缩包很可能是对Java集合框架的详细讲解，涵盖了重要的知识点，包括ArrayList、LinkedList、HashSet、HashMap、TreeSet、TreeMap等主要集合类，以及它们的特点、性能和应用...
java集合总结.pdf
09-14
Java集合总结 Java集合类是Java语言中的一种数据结构，用于存储和操作大量数据。Java集合类提供了多种实现，包括List、Set、Map等，用于解决不同的数据存储和操作问题。本文将从Java集合类的基本概念、Collection...
Java集合总结.txt
06-03
单个集合的学习路线：使用->做实验->画图->分析源码 集合：大小可变的序列，只能存放对象 集合和数组的区别： 1.集合是大小可变的序列，数组在声明后，长度不可变 2.数组只能存放声明时指定的一种数据类型，集合...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 1123
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
浅析synchronized锁升级的原理与实现 1
最新发布
水w的博客
09-01 840
浅析synchronized锁升级的原理与实现
《深入理解 Java 中的适配器模式》
面团到油条的成长日记
08-29 7000
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 5449
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
深度解读并发安全集合的原理及源码
DougLiang的博客
09-01 992
本节主要介绍J.U.C包中的几种并发安全集合：ConcurrentHashMap,ConcurrentLinkedQueue,和ConcurrentLinkedDeque。所谓并发安全集合，相对于普通集合来说，能够保证在多线程环境下向集合中添加数据时的线程安全性。主要讲ConcurrentHashMap在实现线程安全性方面对性能和安全性的合理平衡。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值