java集合

最新推荐文章于 2025-06-02 20:19:11 发布
原创 最新推荐文章于 2025-06-02 20:19:11 发布 · 961 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

本文介绍了Java集合框架，包括List、Set和Map集合的实现类，如ArrayList、LinkedList、HashSet、LinkedHashSet、TreeSet、HashMap、LinkedHashMap和TreeMap。详细讨论了它们的特点、底层结构、增删查改操作以及效率对比，并提到了Collections工具类的作用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

集合

list集合

Arraylist

add增加
set修改
get查询
remove移除

* 数组：只能存储单一数据类型
 * 优点：线性存储 查询速度快
 * 缺点：数组一旦声明长度不可修改
 * List:有序可重复
 * 泛型：限定数据类型
 * <>钻石操作符
 * ArrayList 新增、删除数据慢 查询快
 * LinkedList 新增、删除数快 查询慢
  
public class ArraylistTest {
    @Test
    public void test() {
        int[] array = new int[5];
        array[2] = 2;
        System.out.println(Arrays.toString(array));// [0, 0, 2, 0, 0]
    }
    @Test
    public void test01(){
        List list = new ArrayList();
        byte a = 1;
        short b = 2;
        int c = 3;
        long d = 4L;
        double e = 5.0d;
        float f = 6.0f;
        char g = 'a';
        boolean h = false;
        String i ="桃李不言下自成蹊";
        Persion persion=new Persion();
        list.add(a);
        list.add(b);
        list.add(c);
        list.add(d);
        list.add(e);
        list.add(f);
        list.add(g);
        list.add(h);
        list.add(i);
        list.add(persion);
        System.out.println(list.size()); //10

    }
    @Test
    public void test02(){
        List list=new ArrayList();
        list.add("小王");
        list.add("小白");
        list.add("小王");
        System.out.println(list.get(0));//小王
        System.out.println(list.get(1));//小白
        System.out.println(list.get(2));//小王
    }
    @Test
    public void test03(){
        //3种写法
//        List<String> list= new ArrayList<String>();
//        List<String> list= new ArrayList<>();
//        List<String> list= new ArrayList();
        List<String> list =new ArrayList<>();
        list.add("王鹏飞");

    }
    @Test
    public void test04(){
        List<Integer> list01 =new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list01.add(i);
        }
        System.out.println(list01);//[0, 1, 2, 3, 4]

        List<Integer> list02 =new ArrayList<>(){
            {
                for (int i = 0; i < 5; i++) {
                    add(i);
                }
            }};
        System.out.println(list02);//[0, 1, 2, 3, 4]
    }
    @Test
    public void test05(){
        //不可变集合
        List<Integer> list =List.of(0,1,2,3,4);
        System.out.println(list);

    }
    @Test
    public void test06(){
        //不可变集合转为可变集合
        List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
        System.out.println(list);//[0, 1, 2, 3, 4]
        list.add(6);              //add 增加
        System.out.println(list);//[0, 1, 2, 3, 4, 6]
        list.set(2,20);           //set 修改
        System.out.println(list);//[0, 1, 20, 3, 4, 6]
    }
    @Test
    public void test07(){
        List<String> list=new ArrayList<>(List.of("0","1","2","3","4"));
        System.out.println(list);
        //末尾追加
        list.add("6");
        System.out.println(list);
        //向指定位置添加
        list.add(5,"5");
        System.out.println(list);
        //将指定index位置上的元素从集合中删除
        list.remove(6);
        System.out.println(list);
        //在集合中删除指定元素
        list.remove("5");
        System.out.println(list);
        //删除指定的元素的时候，如果有相同的，就会删除一个
        //建议使用下标去删除
        list.add("王");
        list.add("王");
        System.out.println(list);
        list.remove("王");
        System.out.println(list);
        //更新指定index位置上的值
        list.set(3,"三");
        System.out.println(list);
        //查询指定index位置上元素的值
        System.out.println(list.get(3));
        //输出的结果
        //[0, 1, 2, 3, 4]
        //[0, 1, 2, 3, 4, 6]
        //[0, 1, 2, 3, 4, 5, 6]
        //[0, 1, 2, 3, 4, 5]
        //[0, 1, 2, 3, 4]
        //[0, 1, 2, 3, 4, 王, 王]
        //[0, 1, 2, 3, 4, 王]
        //[0, 1, 2, 三, 4, 王]
        //三
    }
    @Test
    public void test08(){
        List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
        for (int i = 0; i < 5; i++) {
            System.out.println(list.get(i));
        }
        System.out.println("元素个数"+list.size()); //元素个数5

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("++++++++++++++++++++++");
        //for(集合中的元素数据类型 集合中的每一个元素 ：被遍历的集合)
        for (int num : list) {
            System.out.println(num);
        }
    }
    @Test
    public void test09(){
        //迭代的方式
        // 在List 上用迭代器遍历
        List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
        Iterator<Integer> it =list.listIterator();
        while (it.hasNext()){
            Integer next=it.next();
            System.out.println(next);  //01234
        }
        System.out.println("第一次");   //第一次 第二次 第三次
        while (it.hasNext()){
            Integer next=it.next();
            System.out.println(next);
        }
        System.out.println("第二次");
        while (it.hasNext()){
            Integer next=it.next();
            System.out.println(next);
        }
        System.out.println("第三次");
        //
    }
    @Test
    public void test10(){
        List<Integer> list=new ArrayList<>(List.of(0,1,2,3,4));
        list.stream().forEach(System.out::println);
    }
}

泛型

泛型可以理解为参数的数据类型
List list=new ArrayList<>(List.of(0,1,2,3,4));

迭代器

Iterator<Integer> it =list.listIterator();
        while (it.hasNext()){
            Integer next=it.next();
            System.out.println(next);  //0，1，2，3
        }
  • List： 有序可重复 有序指的是下标有序 可重复指的是不同下标位置上可以存储相同值的元素
  • Set： 无序不可重复 录入的顺序和存储的顺序不一致 不可重复指的是相同值的元素不可重复存储
    在这里插入图片描述
    isEmpty
public void test01(){
        Collection c = new ArrayList();
        c.add(1);
        c.add(2);
        System.out.println(c);
        System.out.println(c.isEmpty()); //判断是否为空
    }

快速失败机制

    public void test06(){
        //快速失败机制
        Collection c = new ArrayList();
        c.add("tom");
        c.add("jack");
        c.add("rose");
        c.add("jerry");
        Iterator it = c.iterator();
        while (it.hasNext()){
            Object o = it.next();
            if ("jack".equals(o)){
//                c.remove(o); //集合的方法 会造成数据异常
                it.remove();//迭代器的方法
            }
        }
        System.out.println(c);
    }

遍历集合

    public void test01(){
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        //遍历方式一
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
//            Object next = it.next();
//            System.out.println(next);
        }
        //方式二 增强for
        for (Object o : list) {
            System.out.println(o);
        }
        //方式三 普通for循环
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
    }

Arrays.aslist
//Arrays.aslist 可以生成一个list集合，是一个不可变集合（不能修改）

LinkedList

特点：

  • 元素有序 可重复 可以通过所以访问元素
  • 底层双向链表
  • 增删快 查询慢
  • 线性安全 效率低
public class LinkedList{
    @Test
public void test01(){
        List list = new LinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Iterator it=list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

}

## ListIterator迭代器

List 集合额外提供了一个 listIterator() 方法，该方法返回一个 ListIterator 对象， ListIterator 接口继承了 Iterator 接口，提供了专门操作 List 的方法：

set集合

Set是一个Collection接口的典型子接口。
Set接口代表的集合特点：元素都是唯一的。通常元素都是无序的。

HashSet实现类

  • 元素唯一 无序
  • 底层结构 哈希表
  • 综合效率高
  • 特殊的 hashset 存储student 对象时，
  • hashset 判断两个元素相同的依据是：
    1.先比较元素的hashcode值
    2.元素哈希值相同，在进行equals判断。如果都相同 则元素相同
  public class HashSetTest {
    @Test
    public void test01(){
        HashSet<String> set = new HashSet<>();
        set.add("tom");
        set.add("jock");
        set.add("rose");
        set.add("jerry");
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

linkedhashset

  • 元素唯一 有序
  • 底层结构 哈希表基础上 维护一个链表 用于保证元素的迭代顺序
  • 效率 略低于hashset

Treeset

  • 元素唯一 无序 但实现了 排序

  • 底层结构：红黑树 -一种相对平衡的二叉树

  • 效率 查询效率高于链表

  • 排序原理：

  • 存储元素过程：先存储根节点，其余元素小的放右边，大的放左边

  • 取出元素过程：采用中序遍历 ，即在左中右的遍历

  • TreeSet 集合要所有元素必须实现 comparde 接口 那么元素就可以比较大小了

  • 或者创建TreeSet 集合时通过构造器传入一个比较器，用于 比较元素大小

map集合

  • map 是一个顶层接口 表示一组键值对
  • 特定 key 是唯一 通过key 可以映射到value
  • map 的典型实现类
  • hashmap 、linkedhashmap 、treemap 、hashtable、 properties
public class MapTest {
    @Test
    public void test01(){
    //创建map集合
        HashMap<String, String> map = new HashMap<>();
        //key 是唯一的
        map.put("小白","小黑");
        map.put("小红","小绿");
        map.put("好好","学习");
        map.put("虚线","直线");
        System.out.println(map);
        System.out.println(map.isEmpty());
    }
    @Test
    public void test02(){
        Map<Integer,String> map =new HashMap<>();
        map.put(01,"tom");
        map.put(02,"jer");
        map.put(03,"ros");
        map.put(04,"tom");
        //遍历map集合
        Set<Integer> set =map.keySet();
        for (Integer key : set) {
            String value=map.get(key);
            System.out.println(key+"---"+value);
        }
    }
    @Test
    public void test03(){
        Map<Integer,String> map =new HashMap<>();
        map.put(01,"tom");
        map.put(02,"jerr");
        map.put(03,"rose");
        map.put(04,"tom");
        //遍历
        Set<Map.Entry<Integer,String>> set =map.entrySet();//把每对key-value 看成以恶搞entry封装到一个set集合
        for (Map.Entry<Integer, String> entry : set) {
            //通过entry 获取 key 和value
            Integer key= entry.getKey();
            String value= entry.getValue();
            System.out.println(key+"---"+value);
        }
    }
}

HashMap

  • 特点 key 唯一 无序
  • 底层结构：哈希表
  • 效率：综合效率高
  • key 去重原理， 先比较key 的哈希值 然后哈希值相同，在进行equals比较
 public class HashMapTest {
    @Test
    public void test01(){
        HashMap<String,Integer> map =new HashMap<>();
        map.put("tom",18);
        map.put("jerr",20);
        map.put("rose",19);
        map.put("tom",20);
        //遍历
        Set<String> keySet=map.keySet();
        for (String key : keySet) {
            Integer value=map.get(key);
            System.out.println(key +value);
            //去重了，因为字符串 hashcode 重写了
        }
    }

* linkedHashMap 实现类

  • 是hashmap 的子类
  • 特点：key 唯一 有序
  • 底层结构：哈希表基础维护一个链表 用于保证元素的迭代顺序
  • 效率：略低于hashmap
 * public class LinkedHashMapTest {
    @Test
    public void test01(){
        HashMap<String,Integer> map =new HashMap<>();
        map.put("tom",18);
        map.put("jerr",20);
        map.put("rose",19);
        map.put("tom",20);
        Set<Map.Entry<String,Integer>> entries=map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key =entry.getKey();
            Integer value=entry.getValue();
            System.out.println(key+value);
        }
    }
}

* TreeMap 实现类

  • 特点：key 唯一 无序 但实现了排序
  • 底层结构：红黑树
  • 效率：高于链表
  • TreeMap 集合实现了对象key的排序，所以要求key 必须可以比较大小，即要求key类型实现了comparable接口
  • 或者创建treemap 集合时 传入一个comparator 比较器来比较key 的大小
 public class TreeMapTest {
    @Test
    public void test01(){
        TreeMap<Integer,String> map=new TreeMap<>();
        map.put(110,"警察");
        map.put(120,"医生");
        map.put(119,"急救");
        map.put(114,"坦克");
        Set<Integer> keys =map.keySet();
        for (Integer key : keys) {
            String value=map.get(key);
            System.out.println(key+value);
        }
    }
}

Collections工具类

Collections 是一个操作 Set、List 和 Map 等集合的工具类。Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法：

wpf1391074638
关注
java 集合
04-07
本文将深入探讨Java集合框架的基础知识，包括接口、类、以及它们在实际开发中的应用。 首先，Java集合框架由一系列接口和实现这些接口的类组成。主要的接口有`List`、`Set`和`Queue`，它们各自代表了不同特性的数据...
Java集合
06-13
Java的集合类是一种特别有用的工具类，它可以用于存储数量不等的多个对象，并可以实现常用数据结构，如栈，队列等，除此之外，Java集合还可用于保存具有映射关系的关联数组。 Java的集合大致上可分为：Set,List和...
lists.newarraylist()
热门推荐
qq5621的博客
09-30 3万+
lists.newarraylist()和new arraylist() 区别 List<Integer> list = new ArrayList<Integer>(); List<Integer> list = Lists.newArrayList(); Lists.newArrayList() 其实和 new ArrayList() 几乎一模一样, 唯...
JAVA之list使用
Aaron_Mars的博客
08-02 781
import java.util.ArrayList;或者import java.util.*; 1.定义和初始化 （1）创建空列表，然后逐一添加 ArrayList L=new ArrayList(); L.add(1);L.add("abc"); （2）格式化添加 ArrayList L=new ArrayList(){add(1);add("bc");}}; （3）将Collection...
Java集合初始化：Lists.newArrayList vs new ArrayList()
最新发布
小李同学的博客
06-02 1208
Java集合初始化选择：Guava的Lists.newArrayList与原生new ArrayList<>()对比分析。核心区别在于依赖要求、代码简洁性和功能扩展性。Guava提供可变参数、自动泛型推导和容量优化（如newArrayListWithExpectedSize），适合复杂集合操作和Guava生态项目；而原生方式更轻量，适用于通用场景。性能基准测试显示两者接近，但Guava在初始化优化和高级功能（集合转换、分片等）上更胜一筹。选择应基于项目需求：已有Guava依赖或需要高级功能时推荐
java中Lists.newArrayList和new ArrayList的详细区别？
gb4215287的博客
12-04 6546
java中Lists.newArrayList和new ArrayList的详细区别？
Java ArrayList 类
Catastrophe的博客
04-23 1323
ArrayList是Java集合框架中的一个类，位于java.util包下。它实现了List接口以及其所有可选的接口，如（可序列化）和Cloneable（可克隆）。ArrayList是一个动态数组，可以存储任意数量的非原始类型对象。// 使用自定义Comparator进行排序@Override// 倒序排序});
Lists.newarraylist()和new Arraylist() 区别、Maps.newHashMap()和new HashMap＜＞()的区别
满是遗憾
08-31 1206
新建List集合的方法： 1：List list = new ArrayList(); 2：List list = Lists.newArrayList(); Lists 和 Maps 一样，都属于工具类，所以Map集合也可以这样写： 1：Map<String,Object> map = new HashMap<>(); 2：Map<String,Object> map = Maps.newHashMap(); Lists.newArrayList()其实和new Arr
【Java】Java集合框架思维导图。
04-13
xmind格式的Java集合框架学习导图，包括Collection接口/Map接口以及具体实现类。 同样包含大厂面试题，也在导图中有所体现。 能学到什么： 更加成体系的知识框架，更加全面的、系统的知识。 思维导图： 思维导图具有...
Java集合框架
12-22
Java集合框架是Java编程语言中一个至关重要的组件，它为开发者提供了存储和管理对象的统一方式。集合可以被看作是一个容器，允许我们存放多个对象，并支持常见的操作，如添加、删除和修改元素。 Collection接口是...
Java基础篇：Java集合.pdf
04-24
该文档主要详细总结了Java集合的相关知识，包括Collection和Map接口、Collection接口的子接口List和Set接口以及具体的实现类、存储原理等；Map接口的子接口HashMap、LinkedHashMap、TreeMap、Properties等
java核心知识之集合详解三（List集合）
m0_46198325的博客
03-19 1294
List集合 List接口和Listlterator 接口 ArrayList 和 Vector 实现类 固定List长度
lists.newarraylist()和new arraylist() 区别
qq_41078608的博客
03-10 1349
lists.newarraylist()： List list = new ArrayList(); new arraylist() ： List list = Lists.newArrayList(); Lists和Maps是两个工具类, Lists.newArrayList()其实和new ArrayList()几乎一模一样, 唯一它帮你做的(其实是javac帮你做的), 就是自动推导(不是"倒")尖括号里的数据类型. ...
Lists.newArrayList()和new ArrayList()的区别
DreamSun的博客
12-15 1087
在 Java 7 之后，都允许类型推断 - 在运行时没有区别。java8 的new ArrayList()的里面可以不写类型，java回帮你自动推导类型，所以用哪个都无所谓，看自己喜欢，java8之后我还是喜欢直接new的方便。Lists.newArrayList()其实和new ArrayList()几乎一模一样，唯一它帮你做的(其实是javac帮你做的),就是自动推导尖括号里的数据类型。这个被叫做diamond（钻石）运算符，这个运算符从引用的声明中推断类型。
Java ArrayList用法总结
Willow的博客
08-07 785
com.google.common.collect 通过Lists的静态方法创建ArrayList，该类还可以创建其他的list，如LinkedList、CopyOnWriteArrayList等 List<T> result = Lists.newArrayList(); 进入到ArrayList.java，作者的注释如下： /** * Resizable-array implementation of the <tt>List</tt> interface. I
Lists.newArrayList 和 new ArrayList区别
учёба
03-10 2623
Lists.newArrayList 和 new ArrayList区别
Lists是google对java.util.List类的封装
layman1024的博客
04-28 4183
这个方法在google工具类中也有，源码内容如下   public static  ArrayList newArrayList() {     return new ArrayList(); } 内容是差不多的，唯一的好处就是可以少写泛型的部分。 但这个方法却有丰富的重载：    
Java集合框架深度解析
"Java集合框架详解" Java集合框架是Java编程语言中用于管理和操作对象集合的一组接口和类的集合。这个框架提供了一种统一的方式来处理各种数据结构，包括列表、集合、映射等，极大地提高了代码的可读性和可维护性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值