java集合

最新推荐文章于 2025-06-02 20:19:11 发布

原创最新推荐文章于 2025-06-02 20:19:11 发布 · 961 阅读

0 ·

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