Java 常用数据结构及核心 API（开发 / 刷题高频版）

高频 API：与 ArrayList 通用 API 一致，额外增加链表专属头尾操作（作为队列 / 栈时用）：

LinkedList<String> link = new LinkedList<>();
link.addFirst("a"); // 头部添加
link.addLast("b"); // 尾部添加（等同于 add）
link.getFirst(); // 获取头部元素
link.getLast(); // 获取尾部元素
link.removeFirst(); // 删除头部元素
link.removeLast(); // 删除尾部元素

3. Vector（过时，了解即可）

• 核心特点：底层同 ArrayList（动态数组），线程安全（所有方法加 synchronized），效率低，扩容时默认 2 倍扩容。
• 适用场景：几乎不用，并发场景推荐 CopyOnWriteArrayList。

二、Set 集合（无序、不可重复，无索引）

核心特性：元素无序（存储顺序≠插入顺序，除 LinkedHashSet）、不可重复（底层通过 equals()+hashCode() 保证）、无索引（不能通过索引访问），常用于去重。

1. HashSet（高频首选）

• 核心特点：底层基于HashMap实现（用 key 存元素，value 为默认常量），无序、不可重复，非线程安全，允许存储 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) {}

2. LinkedHashSet

• 核心特点：底层基于LinkedHashMap实现，有序（插入顺序 = 存储顺序）、不可重复，非线程安全，效率略低于 HashSet（需维护链表顺序）。
• API：与 HashSet 完全一致，仅有序性不同。
• 适用场景：去重且需要保证插入顺序。

3. TreeSet

• 核心特点：底层基于红黑树实现，可排序（自然排序 / 自定义排序）、不可重复，非线程安全，不允许存储 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 的最大元素

三、Map 集合（键值对、键唯一，值可重复）

核心特性：以**键值对（Key-Value）**存储数据，Key 唯一（不可重复，底层同 Set）、Value 可重复，支持通过 Key 快速查找 Value，是开发中高频使用的结构。

1. HashMap（高频首选）

• 核心特点：底层基于数组 + 链表 + 红黑树实现（JDK8+），无序（键的存储顺序≠插入顺序），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()) {}

2. LinkedHashMap

• 核心特点：底层基于HashMap + 双向链表实现，有序（插入顺序 / 访问顺序）、Key 唯一，其余特性同 HashMap，效率略低于 HashMap。
• 适用场景：键值对存储且需要保证插入 / 访问顺序（如实现 LRU 缓存的基础）。

API：与 HashMap 完全一致，仅有序性不同，可通过构造方法指定有序类型：

// 构造方法：accessOrder=true 表示访问顺序（get/put 会把元素移到尾部），false 表示插入顺序（默认）
Map<String, Integer> linkMap = new LinkedHashMap<>(16, 0.75f, true);

3. TreeMap

• 核心特点：底层基于红黑树实现，键可排序（自然排序 / 自定义排序），Key 唯一，不允许 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

4. Hashtable（过时，了解即可）

• 核心特点：底层同 HashMap（JDK8 前数组 + 链表），线程安全（所有方法加 synchronized），效率低，不允许 null 键和 null 值。
• 适用场景：几乎不用，并发场景推荐 ConcurrentHashMap。

5. ConcurrentHashMap（并发高频）

• 核心特点：底层同 HashMap（数组 + 链表 + 红黑树），线程安全（JDK8 + 采用 CAS + 分段锁，效率远高于 Hashtable），不允许 null 键和 null 值，是并发场景下的首选 Map。
• API：与 HashMap 基本一致，支持并发操作，无需额外加锁。
• 适用场景：多线程并发的键值对存储 / 查找。

四、Queue/Deque 队列（先进先出 FIFO / 双端队列）

核心特性：Queue 是单端队列（先进先出），仅支持队首出队、队尾入队；Deque 是双端队列（Double Ended Queue），支持队首 / 队尾双向入队、出队，可替代 Stack 实现栈（后进先出）。

1. 单端队列 Queue - PriorityQueue（优先级队列，刷题高频）

• 核心特点：底层基于二叉堆实现，无序，出队时按优先级（自然排序 / 自定义排序）出队，而非插入顺序，非线程安全，允许 null 元素（但不推荐，会抛异常）。
• 默认规则：默认是小顶堆（优先级最高的是最小元素，出队时先出最小值）。
• 适用场景：算法刷题（TopK 问题、堆排序）、业务中的优先级任务调度。

高频 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(); // 是否为空

2. 双端队列 Deque - ArrayDeque（高频首选）

• 核心特点：底层基于动态数组实现，双端入队 / 出队效率高，非线程安全，不允许 null 元素，是替代 Stack 的首选（Stack 底层是 Vector，效率低）。
• 适用场景：需要双端操作的队列、替代 Stack 实现栈（开发 / 刷题首选）。

高频 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();

3. LinkedBlockingQueue（并发队列）

• 核心特点：底层基于双向链表实现，线程安全的阻塞队列，满队时入队阻塞，空队时出队阻塞。
• 适用场景：多线程并发的任务排队（如线程池的任务队列）。

五、Stack 栈（后进先出 LIFO，推荐用 Deque 替代）

• 核心特点：底层基于Vector实现，后进先出，非线程安全，效率低，官方推荐用 Deque（ArrayDeque） 替代（Deque 的 push/pop/peek 方法完全兼容栈操作）。

基础 API（了解即可，不推荐使用）：

Stack<Integer> stack = new Stack<>();
stack.push(1); // 入栈
stack.peek(); // 获取栈顶（不删除）
stack.pop(); // 出栈（删除并返回栈顶）
stack.empty(); // 是否为空（等同于 isEmpty）

六、工具类 Collections（数据结构通用操作）

java.util.Collections 是静态工具类，提供了针对 List、Set、Map 的通用静态方法，用于排序、查找、反转、同步包装等，无需创建对象，直接调用。

高频静态 API

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 异常

七、核心注意事项（开发 / 刷题避坑）

1. 线程安全：默认集合（ArrayList/HashMap/HashSet 等）均非线程安全，并发场景需用专用并发集合（ConcurrentHashMap/CopyOnWriteArrayList/ConcurrentLinkedQueue），而非 Collections 的同步包装。
2. null 值处理：HashMap/HashSet 允许 null（键仅一个），TreeMap/TreeSet/PriorityQueue 不允许 null，ConcurrentHashMap/Hashtable 不允许 null 键 / 值。
3. Set/Map 去重原理：基于 equals() 和 hashCode() 方法，自定义对象作为 Key/Set 元素时，必须重写这两个方法，否则无法保证去重。
4. 遍历与修改：遍历集合时（增强 for / 迭代器），不能直接调用集合的 remove/add 方法，会抛 ConcurrentModificationException，需用迭代器的 remove 方法。
5. 栈的替代：官方推荐用 Deque（ArrayDeque） 替代 Stack，效率更高，API 更通用。

八、高频数据结构选型速查表