系统梳理了 Java 常用数据结构，涵盖 List、Set、Map、Queue/Deque、Stack 五大类及工具类 Collections。详细介绍了 ArrayList、HashMap 等核心实现原理、底层结构、高频 API 及适用场景，并补充了线程安全、null 处理、去重原理及选型速查表，适用于开发与算法刷题参考。
Java 中常用数据结构主要集中在 java.util 包下，核心分为List、Set、Map、Queue/Deque、Stack 五大类，还有配套的工具类 用于数据结构的通用操作。以下按整理，每个结构包含，兼顾开发和算法刷题需求，API 仅列最常用的，简洁易记。
Collections核心特性：元素有序（插入顺序 = 存储顺序）、允许重复元素、支持通过索引快速访问，是开发中最常用的集合类型。
高频 API：
List<String> list = new ArrayList<>();
list.add("a"); // 尾部添加元素
list.add(1, "b"); // 指定索引插入元素
list.get(0); // 根据索引获取元素
list.remove(0); // 根据索引删除元素
list.remove("a"); // 根据元素删除（删除第一个匹配的）
list.set(0, "c"); // 修改指定索引元素
list.contains("a"); // 判断是否包含元素
list.size(); // 获取元素个数
list.isEmpty(); // 判断是否为空
list.clear(); // 清空所有元素
list.iterator(); // 获取迭代器（遍历）
for (String s : list) {} // 增强 for 遍历（推荐）
Deque 接口，可作为队列 / 栈使用。高频 API：与 ArrayList 通用 API 一致，额外增加链表专属头尾操作（作为队列 / 栈时用）：
LinkedList<String> link = new LinkedList<>();
link.addFirst("a"); // 头部添加
link.addLast("b"); // 尾部添加（等同于 add）
link.getFirst(); // 获取头部元素
link.getLast(); // 获取尾部元素
link.removeFirst(); // 删除头部元素
link.removeLast(); // 删除尾部元素
synchronized），效率低，扩容时默认 2 倍扩容。CopyOnWriteArrayList。核心特性：元素无序（存储顺序≠插入顺序，除 LinkedHashSet）、不可重复（底层通过 equals()+hashCode() 保证）、无索引（不能通过索引访问），常用于去重。
null 元素（仅一个），查找 / 增删效率高（O(1)）。高频 API：无索引相关方法，其余与 List 通用（无 get/set/ 带索引的 add/remove）：
Set<String> set = new HashSet<>();
set.add("a"); // 添加元素（重复添加会自动忽略）
set.remove("a"); // 删除元素
set.contains("a"); // 判断是否包含
set.size(); // 元素个数
set.isEmpty(); // 是否为空
set.clear(); // 清空
// 遍历：增强 for / 迭代器（无索引，无法普通 for 遍历）
for (String s : set) {}
null 元素，查找 / 增删效率 O(log n)。高频 API：基础 API 同 HashSet，新增排序相关方法：
// 自然排序（String/Integer 等实现 Comparable 接口）
Set<Integer> treeSet = new TreeSet<>();
// 自定义排序（传入 Comparator）
Set<Integer> customSet = new TreeSet<>((o1, o2) -> o2 - o1); // 降序
customSet.add(3);
customSet.add(1);
customSet.add(2); // 结果：3,2,1
// 排序相关 API
((TreeSet<Integer>) customSet).first(); // 获取最小值
((TreeSet<Integer>) customSet).last(); // 获取最大值
((TreeSet<Integer>) customSet).ceiling(2); // 获取≥2 的最小元素
((TreeSet<Integer>) customSet).floor(2); // 获取≤2 的最大元素
核心特性：以**键值对（Key-Value）**存储数据，Key 唯一（不可重复，底层同 Set）、Value 可重复，支持通过 Key 快速查找 Value，是开发中高频使用的结构。
null 键（仅一个）和 null 值，非线程安全，查找 / 增删效率 O(1)。高频 API：
Map<String, Integer> map = new HashMap<>();
map.put("a", 1); // 添加/修改键值对（key 存在则修改 value）
map.putIfAbsent("a", 2); // 仅当 key 不存在时添加（避免覆盖）
map.get("a"); // 根据 key 获取 value（key 不存在返回 null）
map.getOrDefault("b", 0); // key 不存在返回默认值（推荐）
map.remove("a"); // 根据 key 删除键值对，返回对应 value
map.containsKey("a"); // 判断 key 是否存在
map.containsValue(1); // 判断 value 是否存在
map.size(); // 键值对个数
map.isEmpty(); // 是否为空
map.clear(); // 清空
// 遍历（三种方式，推荐前两种）
// 方式 1：遍历所有 key，再获取 value（最常用）
for (String key : map.keySet()) {
Integer value = map.get(key);
}
// 方式 2：遍历键值对（推荐，一次获取 key+value）
for (Map.Entry<String, Integer> entry : map.entrySet()) {
entry.getKey();
entry.getValue();
entry.setValue(2); // 修改 value
}
// 方式 3：遍历所有 value（仅需 value 时用）
for (Integer value : map.values()) {}
API：与 HashMap 完全一致，仅有序性不同，可通过构造方法指定有序类型：
// 构造方法：accessOrder=true 表示访问顺序（get/put 会把元素移到尾部），false 表示插入顺序（默认）
Map<String, Integer> linkMap = new LinkedHashMap<>(16, 0.75f, true);
null 键，允许 null 值，非线程安全，查找 / 增删效率 O(log n)。高频 API：基础 API 同 HashMap，新增排序相关方法：
// 自然排序（key 需实现 Comparable，如 String/Integer）
Map<Integer, String> treeMap = new TreeMap<>();
// 自定义排序（传入 Comparator，键按降序排列）
Map<Integer, String> customMap = new TreeMap<>((o1, o2) -> o2 - o1);
customMap.put(3, "c");
customMap.put(1, "a");
customMap.put(2, "b"); // 键顺序：3,2,1
// 排序相关 API
customMap.firstKey(); // 获取最小键
customMap.lastKey(); // 获取最大键
customMap.ceilingKey(2); // 获取≥2 的最小键
customMap.floorKey(2); // 获取≤2 的最大键
customMap.subMap(1, 3); // 获取键在 [1,3) 之间的子 Map
synchronized），效率低，不允许 null 键和 null 值。ConcurrentHashMap。null 键和 null 值，是并发场景下的首选 Map。核心特性：Queue 是单端队列（先进先出），仅支持队首出队、队尾入队；Deque 是双端队列（Double Ended Queue），支持队首 / 队尾双向入队、出队，可替代 Stack 实现栈（后进先出）。
null 元素（但不推荐，会抛异常）。高频 API：
// 小顶堆（默认）
Queue<Integer> minHeap = new PriorityQueue<>();
// 大顶堆（自定义 Comparator，刷题高频）
Queue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
maxHeap.offer(3); // 入队（推荐，失败返回 false，区别于 add 抛异常）
maxHeap.offer(1);
maxHeap.offer(2);
maxHeap.peek(); // 获取队首元素（大顶堆为 3，不删除，队列为空返回 null）
maxHeap.poll(); // 出队（删除并返回队首元素 3，队列为空返回 null）
maxHeap.size(); // 元素个数
maxHeap.isEmpty(); // 是否为空
null 元素，是替代 Stack 的首选（Stack 底层是 Vector，效率低）。高频 API：兼具**队列（FIFO）和栈（LIFO）**的所有操作：
Deque<Integer> deque = new ArrayDeque<>();
// ------------ 作为队列（先进先出） ------------
deqeue.offerLast(1); // 队尾入队（等同于 offer）
deqeue.offerFirst(2); // 队首入队（队列一般不用）
deqeue.peekFirst(); // 获取队首（等同于 peek）
deqeue.pollFirst(); // 队首出队（等同于 poll）
// ------------ 作为栈（后进先出，推荐替代 Stack） ------------
deqeue.push(1); // 栈顶入队（等同于 offerFirst）
deqeue.push(2);
deqeue.peek(); // 获取栈顶（等同于 peekFirst，2）
deqeue.pop(); // 栈顶出队（等同于 pollFirst，2）
// 通用 API
deqeue.size();
deqeue.isEmpty();
deqeue.clear();
基础 API（了解即可，不推荐使用）：
Stack<Integer> stack = new Stack<>();
stack.push(1); // 入栈
stack.peek(); // 获取栈顶（不删除）
stack.pop(); // 出栈（删除并返回栈顶）
stack.empty(); // 是否为空（等同于 isEmpty）
java.util.Collections 是静态工具类，提供了针对 List、Set、Map 的通用静态方法，用于排序、查找、反转、同步包装等，无需创建对象，直接调用。
List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 2));
// 1. 排序（List 专属，自然升序）
Collections.sort(list); // [1,2,3]
// 2. 自定义排序（List 专属，传入 Comparator，降序）
Collections.sort(list, (o1, o2) -> o2 - o1); // [3,2,1]
// 3. 二分查找（List 专属，需先排序，找到返回索引，未找到返回负数）
Collections.binarySearch(list, 2); // 排序后查找 2，返回索引 1
// 4. 反转（List 专属）
Collections.reverse(list); // [2,1,3]
// 5. 打乱顺序（List 专属，随机排序）
Collections.shuffle(list);
// 6. 批量添加（所有集合）
Collections.addAll(list, 4, 5, 6); // [3,1,2,4,5,6]
// 7. 获取最大值/最小值（所有集合）
Collections.max(list); // 6
Collections.min(list); // 1
// 8. 线程安全包装（将非线程安全集合转为线程安全，效率一般，并发推荐专用集合）
List<Integer> syncList = Collections.synchronizedList(new ArrayList<>());
Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());
// 9. 不可变集合（防止集合被修改，开发中常用）
List<Integer> unmodList = Collections.unmodifiableList(list);
unmodList.add(7); // 抛 UnsupportedOperationException 异常
null（键仅一个），TreeMap/TreeSet/PriorityQueue 不允许 null，ConcurrentHashMap/Hashtable 不允许 null 键 / 值。equals() 和 hashCode() 方法，自定义对象作为 Key/Set 元素时，必须重写这两个方法，否则无法保证去重。ConcurrentModificationException，需用迭代器的 remove 方法。| 业务需求 | 首选数据结构 | 次选数据结构 |
|---|---|---|
| 有序可重复、频繁查询 | ArrayList | Vector（过时） |
| 有序可重复、频繁增删 | LinkedList | - |
| 去重、无需有序 | HashSet | - |
| 去重、需插入顺序 | LinkedHashSet | - |
| 去重、需排序 | TreeSet | - |
| 键值对、快速查找、无序 | HashMap | Hashtable（过时） |
| 键值对、需插入 / 访问顺序 | LinkedHashMap | - |
| 键值对、需键排序 | TreeMap | - |
| 键值对、并发场景 | ConcurrentHashMap | Collections.synchronizedMap |
| 队列、先进先出 | ArrayDeque（Deque） | LinkedList |
| 队列、优先级调度 | PriorityQueue | - |
| 栈、后进先出 | ArrayDeque（Deque） | Stack（过时） |
| 并发队列 | LinkedBlockingQueue | ConcurrentLinkedQueue |
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 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