Java 集合框架可以理解为：

Java 提供的一套“容器工具”，专门用来存放、管理和操作一组数据。

比如你要保存很多学生姓名：

String name1 = "张三";
String name2 = "李四";
String name3 = "王五";

这样写很麻烦。更好的方式是用集合：

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

names.add("张三");
names.add("李四");
names.add("王五");

这就是集合的作用。

---

1. Java 集合框架整体结构

初学阶段先重点掌握这三类：

List：有序，可重复
Set ：无序，不重复
Map ：键值对

可以这样理解：

类型	特点	例子
List	按顺序存，可以重复	学生名单
Set	不允许重复	身份证号集合
Map	一个 key 对应一个 value	学号对应学生姓名

---

2. List：有序、可重复

List 最常用的实现类是 ArrayList。

例子：保存学生姓名

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> students = new ArrayList<>();

        students.add("张三");
        students.add("李四");
        students.add("王五");
        students.add("张三");

        System.out.println(students);
    }
}

输出：

[张三, 李四, 王五, 张三]

可以看到，List 允许重复。

---

访问元素

System.out.println(students.get(0));
System.out.println(students.get(1));

输出：

张三
李四

注意：下标从 0 开始。

---

修改元素

students.set(1, "赵六");
System.out.println(students);

输出：

[张三, 赵六, 王五, 张三]

---

删除元素

students.remove("张三");
System.out.println(students);

这会删除第一个 "张三"。

如果原来是：

[张三, 赵六, 王五, 张三]

删除后是：

[赵六, 王五, 张三]

---

获取集合长度

System.out.println(students.size());

---

3. 遍历 List

遍历就是把集合中的元素一个个取出来。

方法一：普通 for 循环

for (int i = 0; i < students.size(); i++) {
    System.out.println(students.get(i));
}

适合需要使用下标的情况。

---

方法二：增强 for 循环

for (String name : students) {
    System.out.println(name);
}

更简洁，初学者推荐常用这个。

---

4. Set：无序、不重复

Set 最常用的实现类是 HashSet。

例子：保存不重复的姓名

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> names = new HashSet<>();

        names.add("张三");
        names.add("李四");
        names.add("王五");
        names.add("张三");

        System.out.println(names);
    }
}

输出可能是：

[李四, 张三, 王五]

注意：第二个 "张三" 没有被加入。

因为 Set 不允许重复。

---

Set 的特点

1. 不允许重复
2. 没有固定顺序
3. 不能通过下标访问

所以不能这样写：

names.get(0); // 错误，Set 没有 get(index)

---

遍历 Set

for (String name : names) {
    System.out.println(name);
}

---

5. Map：键值对

Map 用来保存一一对应关系。

最常用的实现类是 HashMap。

比如：

学号 -> 姓名
1001 -> 张三
1002 -> 李四
1003 -> 王五

代码如下：

import java.util.HashMap;

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

        students.put(1001, "张三");
        students.put(1002, "李四");
        students.put(1003, "王五");

        System.out.println(students);
    }
}

输出可能是：

{1001=张三, 1002=李四, 1003=王五}

---

6. Map 的基本操作

添加数据

students.put(1001, "张三");

这里：

1001

是 key。

"张三"

是 value。

---

根据 key 获取 value

String name = students.get(1001);
System.out.println(name);

输出：

张三

---

修改 value

如果 key 已经存在，再次 put 会覆盖原来的值。

students.put(1001, "赵六");
System.out.println(students.get(1001));

输出：

赵六

---

删除数据

students.remove(1001);

---

判断是否存在某个 key

System.out.println(students.containsKey(1002));

输出：

true

---

判断是否存在某个 value

System.out.println(students.containsValue("李四"));

---

7. 遍历 Map

Map 不是一个个单独的值，而是一组一组的键值对。

推荐使用这种方式：

for (Integer id : students.keySet()) {
    String name = students.get(id);
    System.out.println(id + " -> " + name);
}

输出：

1001 -> 张三
1002 -> 李四
1003 -> 王五

也可以用 entrySet()：

for (Map.Entry<Integer, String> entry : students.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

完整代码需要导入：

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

---

8. 集合中存放对象

前面的例子都是存字符串。实际开发中，经常存对象。

比如定义一个学生类：

class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void showInfo() {
        System.out.println(name + "，" + age + "岁");
    }
}

然后用 ArrayList 保存多个学生：

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();

        students.add(new Student("张三", 18));
        students.add(new Student("李四", 20));
        students.add(new Student("王五", 19));

        for (Student s : students) {
            s.showInfo();
        }
    }
}

输出：

张三，18岁
李四，20岁
王五，19岁

这个例子非常重要，因为真实项目里集合经常这样用。

---

9. 泛型：<String>、<Integer> 是什么？

你会看到这种写法：

ArrayList<String> names = new ArrayList<>();
HashSet<Integer> numbers = new HashSet<>();
HashMap<Integer, String> students = new HashMap<>();

尖括号里的内容叫泛型。

它的作用是规定集合里能放什么类型的数据。

比如：

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

表示这个集合只能放字符串。

names.add("张三"); // 正确
names.add(100);   // 错误

再比如：

HashMap<Integer, String> students = new HashMap<>();

表示：

key 是 Integer 类型
value 是 String 类型

也就是：

学号 -> 姓名

---

10. ArrayList 和 LinkedList 的区别

List 有两个常见实现类：

ArrayList
LinkedList

初学阶段先用 ArrayList 就够了。

简单区别：

类型	特点	适合场景
ArrayList	查询快	经常根据下标查数据
LinkedList	插入、删除较方便	经常在中间插入删除

例如：

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

这是最常用的。

---

11. HashSet 和 TreeSet 的区别

Set 也有多个实现类：

类型	特点
HashSet	无序，不重复，速度快
TreeSet	不重复，会自动排序

例子：

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<Integer> nums = new TreeSet<>();

        nums.add(30);
        nums.add(10);
        nums.add(20);
        nums.add(10);

        System.out.println(nums);
    }
}

输出：

[10, 20, 30]

可以看到：

1. 重复的 10 被去掉
2. 数字自动排序

---

12. HashMap 和 TreeMap 的区别

Map 也有多个实现类：

类型	特点
HashMap	key 无序，速度快
TreeMap	key 自动排序

例子：

import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        TreeMap<Integer, String> students = new TreeMap<>();

        students.put(1003, "王五");
        students.put(1001, "张三");
        students.put(1002, "李四");

        System.out.println(students);
    }
}

输出：

{1001=张三, 1002=李四, 1003=王五}

它会按照 key 排序。

---

13. 一个完整例子：学生管理

下面用集合做一个小型学生列表。

import java.util.ArrayList;

class Student {
    private int id;
    private String name;
    private int age;

    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void showInfo() {
        System.out.println("学号：" + id + "，姓名：" + name + "，年龄：" + age);
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();

        students.add(new Student(1001, "张三", 18));
        students.add(new Student(1002, "李四", 20));
        students.add(new Student(1003, "王五", 19));

        System.out.println("所有学生：");
        for (Student s : students) {
            s.showInfo();
        }

        System.out.println("查找学号为 1002 的学生：");
        for (Student s : students) {
            if (s.getId() == 1002) {
                s.showInfo();
            }
        }
    }
}

输出：

所有学生：
学号：1001，姓名：张三，年龄：18
学号：1002，姓名：李四，年龄：20
学号：1003，姓名：王五，年龄：19
查找学号为 1002 的学生：
学号：1002，姓名：李四，年龄：20

---

14. 如果用 HashMap 管理学生

如果经常根据学号查学生，用 HashMap 更合适。

import java.util.HashMap;

class Student {
    private int id;
    private String name;
    private int age;

    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public void showInfo() {
        System.out.println("学号：" + id + "，姓名：" + name + "，年龄：" + age);
    }
}

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, Student> studentMap = new HashMap<>();

        studentMap.put(1001, new Student(1001, "张三", 18));
        studentMap.put(1002, new Student(1002, "李四", 20));
        studentMap.put(1003, new Student(1003, "王五", 19));

        Student s = studentMap.get(1002);

        if (s != null) {
            s.showInfo();
        } else {
            System.out.println("没有找到该学生");
        }
    }
}

这样查找更直接：

studentMap.get(1002);

不用自己写循环遍历。

---

15. 什么时候用 List、Set、Map？

初学者可以这样选：

用 List

当你需要保存一组有顺序的数据时：

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

比如：

学生名单
商品列表
成绩列表
评论列表

---

用 Set

当你希望数据不能重复时：

HashSet<String> phoneNumbers = new HashSet<>();

比如：

手机号去重
用户名去重
身份证号去重
标签集合

---

用 Map

当你需要通过一个 key 快速找到一个 value 时：

HashMap<Integer, Student> students = new HashMap<>();

比如：

学号 -> 学生
用户名 -> 用户对象
商品编号 -> 商品信息
单词 -> 出现次数

---

16. 常用集合方法总结

List 常用方法

list.add(value);       // 添加
list.get(index);       // 获取
list.set(index, value);// 修改
list.remove(index);    // 删除
list.size();           // 长度
list.contains(value);  // 是否包含

---

Set 常用方法

set.add(value);        // 添加
set.remove(value);     // 删除
set.contains(value);   // 是否包含
set.size();            // 长度

---

Map 常用方法

map.put(key, value);       // 添加或修改
map.get(key);              // 根据 key 获取 value
map.remove(key);           // 删除
map.containsKey(key);      // 是否包含 key
map.containsValue(value);  // 是否包含 value
map.size();                // 长度

---

17. 最重要的一句话

Java 集合框架的核心可以先记成：

List：一列数据，可以重复，有顺序
Set ：一组数据，不能重复
Map ：一组键值对，通过 key 找 value

对于初学者，优先掌握这三个：

ArrayList
HashSet
HashMap

它们已经能覆盖大多数基础开发场景。