Java三大集合：List、Set、Map

一、集合的本质

[二、特性 + 用法 + 场景](#二、特性 + 用法 + 场景)

[1. List：有序可重复的 "动态数组"](#1. List：有序可重复的 “动态数组”)

常用实现类对比：

适用场景：

[2. Set：无序不可重复的 "无重复集合"](#2. Set：无序不可重复的 “无重复集合”)

核心用法示例：

常用实现类对比：

适用场景：

[3. Map：键值对存储的 "字典"](#3. Map：键值对存储的 “字典”)

List、Set、Map 作为最基础也最常用的三种集合类型，各自有着鲜明的特性和适用场景。本文梳理清楚它们的区别、用法和最佳实践，在开发中选对集合、少走弯路。

一、集合的本质

Java 集合框架的核心目的是存储、管理和操作一组对象，相比数组，集合支持动态扩容、提供丰富的操作方法（增删改查、排序、筛选等），是处理批量数据的首选。

List、Set 属于集合接口的子接口，而 Map 是独立的顶级接口（存储键值对），三者的核心差异体现在元素是否有序、是否允许重复上：

集合类型	核心特征	是否允许重复元素	是否有序	核心实现类
List	有序可重复	是	插入有序（索引有序）	ArrayList、LinkedList
Set	无序不可重复	否	无序（HashSet）/ 有序（TreeSet）	HashSet、TreeSet、LinkedHashSet
Map	键值对存储，键唯一	值可重复、键不可	无序（HashMap）/ 有序（TreeMap）	HashMap、TreeMap、LinkedHashMap

二、特性 + 用法 + 场景

1. List：有序可重复的 "动态数组"

List 的核心是有序性 （按插入顺序保存，可通过索引访问）和可重复性（允许元素重复），就像我们日常用的 "待办清单"，可以按顺序查看、修改指定位置的内容。

java 复制代码

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

public class ListDemo {
    public static void main(String[] args) {
        // 推荐使用接口声明，实现类实例化（面向接口编程）
        List<String> fruitList = new ArrayList<>();
        
        // 1. 添加元素
        fruitList.add("苹果");
        fruitList.add("香蕉");
        fruitList.add("苹果"); // 允许重复添加
        
        // 2. 按索引访问元素
        System.out.println("索引1的元素：" + fruitList.get(1)); // 输出：香蕉
        
        // 3. 修改元素
        fruitList.set(0, "红苹果");
        
        // 4. 遍历元素
        for (String fruit : fruitList) {
            System.out.println(fruit); // 输出：红苹果、香蕉、苹果
        }
        
        // 5. 删除元素
        fruitList.remove(2); // 删除索引2的"苹果"
    }
}

常用实现类对比：

ArrayList：底层是动态数组，查询快（随机访问）、增删慢（需移动元素），适合读多写少的场景；
LinkedList：底层是双向链表，查询慢（需遍历）、增删快（仅修改节点引用），适合写多读少（如队列、栈）的场景。

适用场景：

需要按顺序存取数据、允许重复元素、需通过索引快速访问的场景（如：订单列表、用户留言列表）。

2. Set：无序不可重复的 "无重复集合"

Set 的核心是不可重复性（元素唯一），默认无序（HashSet），就像我们的 "用户标签库"，不允许同一个标签重复出现。

核心用法示例：

java 复制代码

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

public class SetDemo {
    public static void main(String[] args) {
        Set<String> tagSet = new HashSet<>();
        
        // 1. 添加元素
        tagSet.add("Java");
        tagSet.add("Spring");
        tagSet.add("Java"); // 重复元素，添加失败
        
        // 2. 遍历元素（无序）
        for (String tag : tagSet) {
            System.out.println(tag); // 输出：Java、Spring（顺序不固定）
        }
        
        // 3. 判断元素是否存在
        boolean hasJava = tagSet.contains("Java");
        System.out.println("是否包含Java标签：" + hasJava); // 输出：true
        
        // 4. 去重场景（核心价值）
        List<String> rawList = List.of("a", "b", "a", "c");
        Set<String> uniqueSet = new HashSet<>(rawList);
        System.out.println("去重后的集合：" + uniqueSet); // 输出：[a, b, c]
    }
}

常用实现类对比：

HashSet ：底层基于 HashMap 实现，无序、查询快，依赖元素的hashCode()和equals()保证唯一性；
LinkedHashSet：继承 HashSet，底层维护链表，保证插入顺序，兼具有序和去重；
TreeSet：底层基于红黑树，可对元素自然排序（或自定义排序），但性能略低于 HashSet。

适用场景：

需要去重、无需按顺序存取数据的场景（如：用户标签、抽奖名单（避免重复中奖）、缓存的唯一键集合）。

3. Map：键值对存储的 "字典"

Map 的核心是键值对（Key-Value） 存储，键（Key）唯一、值（Value）可重复，就像我们的 "字典"------ 通过唯一的 "单词（Key）" 找到对应的 "释义（Value）"。

核心用法示例：

java 复制代码

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

public class MapDemo {
    public static void main(String[] args) {
        Map<Integer, String> userMap = new HashMap<>();
        
        // 1. 添加键值对
        userMap.put(1, "张三");
        userMap.put(2, "李四");
        userMap.put(1, "张小三"); // 键重复，覆盖原有值
        
        // 2. 通过键获取值
        String userName = userMap.get(2);
        System.out.println("ID为2的用户：" + userName); // 输出：李四
        
        // 3. 遍历Map（三种方式）
        // 方式1：遍历所有键
        Set<Integer> keys = userMap.keySet();
        for (Integer key : keys) {
            System.out.println("键：" + key + "，值：" + userMap.get(key));
        }
        
        // 方式2：遍历所有键值对（推荐，效率高）
        for (Map.Entry<Integer, String> entry : userMap.entrySet()) {
            System.out.println("ID：" + entry.getKey() + "，姓名：" + entry.getValue());
        }
        
        // 方式3：遍历所有值（不关心键时）
        for (String value : userMap.values()) {
            System.out.println("姓名：" + value);
        }
        
        // 4. 判断键是否存在
        boolean hasKey1 = userMap.containsKey(1);
        System.out.println("是否包含键1：" + hasKey1); // 输出：true
    }
}

常用实现类对比：

HashMap：底层是哈希表 + 红黑树（JDK1.8+），无序、查询 / 增删快，线程不安全，是日常开发首选；
LinkedHashMap：继承 HashMap，维护插入顺序，有序且高效；
TreeMap：基于红黑树，可按键排序，适合需要排序的键值对场景；
Hashtable：线程安全但性能差，已被 ConcurrentHashMap 替代，不推荐使用。

适用场景：

需要通过唯一标识（键）快速查找对应数据的场景（如：用户 ID 映射用户信息、配置项存储、缓存数据）。

三、使用集合的核心注意事项

Set/Map 的去重依赖hashCode()和equals()：如果存储自定义对象，必须重写这两个方法，否则无法保证唯一性；

java 复制代码

// 自定义User类示例（重写hashCode和equals）
class User {
    private Integer id;
    private String name;
    
    // 构造器、getter/setter省略
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id.equals(user.id); // 按ID判断相等
    }
    
    @Override
    public int hashCode() {
        return id.hashCode(); // 基于ID生成哈希值
    }
}

集合遍历中修改元素要注意 ：直接遍历 List 时用remove()会抛出ConcurrentModificationException，推荐使用迭代器或removeIf()；
线程安全问题 ：ArrayList、HashSet、HashMap 都是线程不安全的，多线程场景需使用CopyOnWriteArrayList、ConcurrentHashMap等线程安全集合；
选择合适的实现类：优先根据 "查询 / 增删效率""是否有序""是否线程安全" 选择，而非无脑用 ArrayList/HashMap。