Java 集合框架分为 Collection 和 Map 两大体系。Collection 包含 List（ArrayList 基于数组，查询快；LinkedList 基于链表，增删快）、Set（HashSet 去重无序，TreeSet 排序）及 Queue。Map 包含 HashMap（哈希表，高效）、LinkedHashMap（有序）、TreeMap（排序）及 ConcurrentHashMap（线程安全）。本文详解各集合底层原理、核心方法、适用场景及常见坑点，帮助开发者根据业务需求精准选型，提升开发效率。
Java 集合框架是开发中最常用的工具类集合，它统一管理了各类数据存储结构（数组、链表、红黑树等），提供了便捷的增删改查方法，解决了数组固定长度、操作繁琐的痛点。本文从集合框架整体结构出发，详解核心集合类的原理、用法和适用场景，搭配实战代码，让你既能理解底层逻辑，又能在开发中灵活选型。
Java 集合框架主要分为 Collection（单列集合） 和 Map（双列集合） 两大阵营，所有集合类都围绕这两个核心接口展开：
List 接口的核心特点是 有序（元素插入顺序 = 遍历顺序）、可重复，支持通过索引操作元素，适合需要按位置访问、频繁查询的场景。
oldCapacity + (oldCapacity >> 1)），扩容时会复制原数组元素到新数组；import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo {
public static void main(String[] args) {
// 1. 创建 ArrayList（存储字符串）
List<String> list = new ArrayList<>();
// 2. 添加元素（有序、可重复）
list.add("Java");
list.add("Python");
list.add("Java"); // 允许重复元素
System.out.println("添加后：" + list); // 输出：[Java, Python, Java]
// 3. 按索引访问元素
String element = list.get(1);
System.out.println("索引 1 的元素：" + element); // 输出：Python
// 4. 按索引修改元素
list.set(2, "C++");
System.out.println("修改后：" + list); // 输出：[Java, Python, C++]
// 5. 按索引删除元素
list.remove(1);
System.out.println("删除后：" + list); // 输出：[Java, C++]
// 6. 遍历元素（三种方式）
// 方式 1：普通 for 循环（适合需要索引的场景）
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
System.out.println();
// 方式 2：增强 for 循环（简洁）
for (String s : list) {
System.out.print(s + " ");
}
System.out.println();
// 方式 3：迭代器（支持遍历中删除元素）
java.util.Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
if (s.equals("Java")) {
iterator.remove(); // 安全删除，不会触发 ConcurrentModificationException
}
}
System.out.println("迭代器删除后：" + list); // 输出：[C++]
}
}
import java.util.LinkedList;
import java.util.List;
public class LinkedListDemo {
public static void main(String[] args) {
List<Integer> list = new LinkedList<>();
// 添加元素
list.add(10);
list.add(20);
list.add(30);
System.out.println("添加后：" + list); // 输出：[10, 20, 30]
// 在指定位置插入元素（增删效率高）
list.add(1, 15);
System.out.println("插入后：" + list); // 输出：[10, 15, 20, 30]
// 删除指定元素
list.remove(Integer.valueOf(20));
System.out.println("删除后：" + list); // 输出：[10, 15, 30]
// 链表特有的操作（作为队列/栈）
LinkedList<Integer> linkedList = (LinkedList<Integer>) list;
linkedList.addFirst(5); // 头部添加
linkedList.addLast(35); // 尾部添加
System.out.println("头部 + 尾部添加后：" + linkedList); // 输出：[5, 10, 15, 30, 35]
int first = linkedList.getFirst(); // 获取头部元素
int last = linkedList.getLast(); // 获取尾部元素
System.out.println("头部：" + first + "，尾部：" + last); // 输出：头部：5，尾部：35
}
}
| 特性 | ArrayList | LinkedList |
|---|---|---|
| 底层结构 | 数组 | 双向链表 |
| 查询效率 | 高（O(1)） | 低（O(n)） |
| 增删效率 | 低（O(n)，需移动元素） | 高（O(1)，仅改引用） |
| 内存占用 | 连续内存，可能有冗余 | 非连续内存，每个节点有额外引用开销 |
| 适用场景 | 频繁查询、少量增删 | 频繁增删、少量查询 |
Set 接口的核心特点是 无序（元素插入顺序≠遍历顺序）、不可重复（基于 equals() 和 hashCode() 判断），适合需要去重的场景。
hashCode() 计算哈希值，若哈希值不同则元素不同；若哈希值相同，再通过 equals() 判断是否相同，两者都相同则视为重复元素。import java.util.HashSet;
import java.util.Set;
public class HashSetDemo {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
// 添加元素（不可重复）
set.add("Apple");
set.add("Banana");
set.add("Apple"); // 重复元素，添加失败
System.out.println("添加后：" + set); // 输出：[Apple, Banana]（无序）
// 删除元素
set.remove("Banana");
System.out.println("删除后：" + set); // 输出：[Apple]
// 判断元素是否存在
boolean contains = set.contains("Apple");
System.out.println("是否包含 Apple：" + contains); // 输出：true
// 遍历元素（增强 for/迭代器，无普通 for 循环，因为无序无索引）
for (String s : set) {
System.out.print(s + " "); // 输出：Apple
}
// 去重场景示例：数组去重
String[] arr = {"Java", "Python", "Java", "C++"};
Set<String> uniqueSet = new HashSet<>();
for (String s : arr) {
uniqueSet.add(s);
}
System.out.println("\n数组去重后：" + uniqueSet); // 输出：[Java, Python, C++]
}
}
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
// 1. 自然排序（Integer 按数值升序）
TreeSet<Integer> numSet = new TreeSet<>();
numSet.add(30);
numSet.add(10);
numSet.add(20);
System.out.println("自然排序：" + numSet); // 输出：[10, 20, 30]
// 2. 自定义排序（字符串按长度降序）
TreeSet<String> strSet = new TreeSet<>((s1, s2) -> s2.length() - s1.length());
strSet.add("Apple");
strSet.add("Banana");
strSet.add("Pear");
System.out.println("自定义排序（长度降序）：" + strSet); // 输出：[Banana, Apple, Pear]
}
}
Queue 接口遵循 先进先出（FIFO） 原则，元素从队列尾部添加，从头部删除，适合任务排队、消息传递等场景。
offer(E e)：添加元素到队列尾部，失败返回 false（推荐使用，不抛出异常）；poll()：删除并返回队列头部元素，队列为空返回 null；peek()：返回队列头部元素，不删除，队列为空返回 null；remove()：删除并返回队列头部元素，队列为空抛出异常。import java.util.LinkedList;
import java.util.Queue;
public class QueueDemo {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
// 添加元素到队列
queue.offer("任务 1");
queue.offer("任务 2");
queue.offer("任务 3");
System.out.println("队列初始化：" + queue); // 输出：[任务 1, 任务 2, 任务 3]
// 获取头部元素（不删除）
String head = queue.peek();
System.out.println("队列头部：" + head); // 输出：任务 1
// 删除并返回头部元素
String task = queue.poll();
System.out.println("执行任务：" + task); // 输出：执行任务：任务 1
System.out.println("执行后队列：" + queue); // 输出：[任务 2, 任务 3]
}
}
Map 接口存储 键值对（key-value），key 唯一（不可重复），value 可重复，每个 key 对应一个 value，适合通过 key 快速查找 value 的场景（如用户信息存储、配置项管理）。
hashCode() 和 equals() 判断。import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashMapDemo {
public static void main(String[] args) {
// 1. 创建 HashMap（存储用户 ID-用户名）
Map<Integer, String> userMap = new HashMap<>();
// 2. 添加键值对（key 唯一，重复 key 会覆盖 value）
userMap.put(1001, "张三");
userMap.put(1002, "李四");
userMap.put(1001, "张三三"); // 重复 key，覆盖 value
System.out.println("添加后：" + userMap); // 输出：{1001=张三三，1002=李四}
// 3. 根据 key 获取 value
String username = userMap.get(1001);
System.out.println("用户 1001 的名称：" + username); // 输出：张三三
// 4. 判断 key 是否存在
boolean hasKey = userMap.containsKey(1002);
System.out.println("是否存在 key=1002：" + hasKey); // 输出：true
// 5. 删除键值对
userMap.remove(1002);
System.out.println("删除后：" + userMap); // 输出：{1001=张三三}
// 6. 遍历 HashMap（三种方式）
// 方式 1：遍历 key 集合
Set<Integer> keySet = userMap.keySet();
for (Integer key : keySet) {
System.out.println( + key + + userMap.get(key));
}
Set<Map.Entry<Integer, String>> entrySet = userMap.entrySet();
(Map.Entry<Integer, String> entry : entrySet) {
System.out.println( + entry.getKey() + + entry.getValue());
}
(String value : userMap.values()) {
System.out.println( + value);
}
}
}
import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapDemo {
public static void main(String[] args) {
// 1. 按插入顺序排序（默认）
Map<String, Integer> insertOrderMap = new LinkedHashMap<>();
insertOrderMap.put("Apple", 10);
insertOrderMap.put("Banana", 20);
insertOrderMap.put("Pear", 15);
System.out.println("插入顺序：" + insertOrderMap); // 输出：{Apple=10, Banana=20, Pear=15}
// 2. 按访问顺序排序（LRU 策略）
Map<String, Integer> accessOrderMap = new LinkedHashMap<>(16, 0.75f, true);
accessOrderMap.put("Apple", 10);
accessOrderMap.put("Banana", 20);
accessOrderMap.put("Pear", 15);
// 访问 Banana 和 Apple
accessOrderMap.get("Banana");
accessOrderMap.get("Apple");
System.out.println("访问顺序：" + accessOrderMap); // 输出：{Pear=15, Banana=20, Apple=10}
}
}
import java.util.TreeMap;
public class TreeMapDemo {
public static void main(String[] args) {
// 1. 自然排序（Integer 按数值升序）
TreeMap<Integer, String> numMap = new TreeMap<>();
numMap.put(3, "C");
numMap.put(1, "A");
numMap.put(2, "B");
System.out.println("自然排序：" + numMap); // 输出：{1=A, 2=B, 3=C}
// 2. 自定义排序（key 按字符串长度降序）
TreeMap<String, Integer> strMap = new TreeMap<>((s1, s2) -> s2.length() - s1.length());
strMap.put("Apple", 10);
strMap.put("Banana", 20);
strMap.put("Pear", 15);
System.out.println("自定义排序：" + strMap); // 输出：{Banana=20, Apple=10, Pear=15}
}
}
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentHashMapDemo {
public static void main(String[] args) throws InterruptedException {
Map<Integer, Integer> map = new ConcurrentHashMap<>();
Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
map.put(i, i);
}
};
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("最终元素个数：" + map.size()); // 输出：1000（无并发问题）
}
}
| 场景需求 | 推荐集合类 | 核心原因 |
|---|---|---|
| 频繁查询、少量增删 | ArrayList | 数组实现，查询效率 O(1) |
| 频繁增删、少量查询 | LinkedList | 链表实现，增删效率 O(1) |
| 元素去重（无序） | HashSet | 哈希表实现，去重效率高 |
| 元素去重（有序） | LinkedHashSet | 保持插入顺序，兼顾去重和有序 |
| 元素去重 + 排序 | TreeSet | 红黑树排序，自动去重 |
| 任务排队、先进先出 | LinkedList（Queue） | 双端队列实现，增删效率高 |
| 键值对存储（无序、高效） | HashMap | 哈希表实现，查询 O(1) |
| 键值对存储（有序） | LinkedHashMap | 保持插入 / 访问顺序 |
| 键值对存储（排序） | TreeMap | 按 key 排序，支持自定义比较器 |
| 多线程并发键值对存储 | ConcurrentHashMap | 线程安全，并发效率高 |
| 数组去重 | HashSet | 一行代码实现，简洁高效 |
| 用户信息、配置项存储 | HashMap/LinkedHashMap | 按 key 快速查询 value |
Iterator.remove()）或增强 for 循环配合标记；Java 集合框架是开发中的'工具箱'，核心是根据业务场景选择合适的存储结构：
掌握集合的底层原理（数组、链表、红黑树）能帮助你更精准地选型，而熟练使用常用操作（增删改查、遍历）能提高开发效率。建议多结合实际场景练习，理解不同集合的适用边界，避免'一刀切'使用 ArrayList 或 HashMap。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online