Java中的集合

Java 集合核心：List、Set、Map

集合都在 java.util 包下，用来存放多个对象（不能直接存基本类型，存包装类）
三大接口区别一句话总结：

• List：有序、可重复（按存入顺序排列，允许元素重复）
• Set：无序（部分实现有序）、不可重复，没有下标（元素不能重复）
• Map：键值对(key-value)，key不可重复，value可重复

包装类，即把普通基础类型，变成引用类型的写法。常见的对应：int/Integer；long/Long；float/Float；double/Double

一、List 接口

常用实现类：

1. ArrayList：数组实现，查询快、增删慢，线程不安全（最常用）
2. LinkedList：双向链表，增删快、查询慢（理解一下即可）

List 示例（ArrayList）

import java.util.ArrayList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        // 定义List，泛型指定存放String
        List<String> list = new ArrayList<>();
        // 添加元素
        list.add("张三");
        list.add("李四");
        list.add("张三"); // List允许重复

        System.out.println("全部元素：" + list);
        System.out.println("下标0元素：" + list.get(0));
        System.out.println("李四所在位置：" + list.indexOf("李四"));

        // 删除元素
        list.remove("李四");
        System.out.println("删除后：" + list);

        //修改元素
        list.set(1, "王五");

        // 遍历
        for (String s : list) {
            System.out.println(s);
        }
    }
}

输出：

全部元素：[张三, 李四, 张三]
下标0元素：张三
李四所在位置：1
删除后：[张三, 张三]
张三
王五

二、Set 接口

常用实现类：

1. HashSet：无序、去重，底层HashMap，查询快（最常用）

Set 判断重复：先判断 hashCode()，再判断 equals()

Set 示例（HashSet）

import java.util.HashSet;
import java.util.Set;

public class App {
    public static void main(String[] args) {
        // 【增】创建Set并添加元素
        Set<String> set = new HashSet<>();
        set.add("张三");
        set.add("李四");
        set.add("张三"); // Set自动去重，不会添加重复元素

        System.out.println("全部元素：" + set);
        System.out.println("Set大小：" + set.size());

        // 【查】检查元素是否存在
        boolean hasZhangSan = set.contains("张三");
        System.out.println("是否包含'张三'：" + hasZhangSan);

        // 【改】Set无直接修改方法，需先删后增
        // 将"李四"改为"王五"
        if (set.remove("李四")) {
            set.add("王五");
            System.out.println("修改后：" + set);
        }

        // 【删】删除指定元素
        set.remove("张三");
        System.out.println("删除'张三'后：" + set);

        // 【遍历】增强for循环（推荐）
        System.out.println("遍历结果：");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

输出（顺序不固定，HashSet无序）：

全部元素：[李四, 张三]
Set大小：2
是否包含'张三'：true
修改后：[张三, 王五]
删除'张三'后：[王五]
遍历结果：
王五

三、Map 接口

存储格式：key = value，key唯一，value可以重复
常用实现类：

1. HashMap：无序，key不重复，查询极快（最常用）

Map 示例（HashMap）

import java.util.HashMap;
import java.util.Map;

public class App {
    public static void main(String[] args) {
        var map = new HashMap<Integer, String>();

        // 【增】put添加键值对，key重复则覆盖旧value
        map.put(1, "Java");
        map.put(2, "C#");
        map.put(3, "Go");
        System.out.println("初始Map：" + map);

        // 【查】get获取值，不存在返回null
        System.out.println("key=2的值：" + map.get(2));
        // getOrDefault避免null（Java 8+，Java 25推荐）
        System.out.println("key=99的值：" + map.getOrDefault(99, "默认值"));

        // 【改】put覆盖已有key；或用replace精确更新
        map.put(1, "Python"); // 覆盖key=1
        map.replace(2, "Rust"); // 仅当key存在时更新
        System.out.println("修改后：" + map);

        // 【删】remove删除指定key
        map.remove(3);
        // remove(key, value) 仅当键值匹配时才删除（防误删）
        map.remove(1, "Java"); // key=1当前值为"Python"，不匹配，不会删除
        System.out.println("删除后：" + map);

        // 遍历方式1：通过key遍历
        for (Integer key : map.keySet()) {
            System.out.println(key + " -> " + map.get(key));
        }
    }
}

输出：

初始Map：{1=Java, 2=C#, 3=Go}
key=2的值：C#
key=99的值：默认值
修改后：{1=Python, 2=Rust, 3=Go}
删除后：{1=Python, 2=Rust}
1 -> Python
2 -> Rust

✅ 快速对比表

集合	是否有序	是否允许重复	底层常用实现
List	✅插入有序	✅允许重复	ArrayList(数组)
Set	HashSet无序；	❌不允许重复	HashSet(哈希表)
Map	HashMap无序；	key不重复，value可重复	HashMap(哈希表)

常见使用场景

1. 需要保存顺序、允许重复数据 → ArrayList
2. 需要自动去重，不关心顺序 → HashSet
3. 需要根据key快速查找数据（字典） → HashMap

各种类型之间时常会用到转换（比如权限去重），具体语法可以遇到再查