Java基本数据结构与高频接口实战手册

1. Java 基本数据结构怎么选#

1.1 `Array`（数组）#

访问：按下标 O(1)。
插入删除：中间位置通常 O(n)。
适用：固定长度、频繁随机访问。

1
int[] arr = {10, 20, 30};
2
System.out.println(arr[1]); // 20

1.2 `ArrayList`#

本质是动态数组。
随机访问快，尾部追加快。
中间插入和删除相对慢。

1
import java.util.ArrayList;
2
import java.util.List;
3

4
public class ArrayListCrudDemo {
5
    public static void main(String[] args) {
6
        List<String> list = new ArrayList<>();
7

8
        // 1) 新增
9
        list.add("A");            // 尾部追加
10
        list.add("B");
11
        list.add(1, "X");         // 指定索引插入，结果 [A, X, B]
12

13
        // 2) 查询
14
        System.out.println(list.get(0));      // A
15
        System.out.println(list.contains("B"));// true
16
        System.out.println(list.indexOf("X")); // 1
17
        System.out.println(list.size());       // 3
18

19
        // 3) 修改
20
        list.set(2, "C"); // [A, X, C]
21

22
        // 4) 删除
23
        String removedByIndex = list.remove(1); // 删除索引 1 的元素 X
24
        boolean removedByValue = list.remove("A"); // 删除元素 A
25
        System.out.println(removedByIndex);        // X
26
        System.out.println(removedByValue);        // true
27

28
        // 5) 遍历
29
        for (String item : list) {
30
            System.out.println(item);
31
        }
32

33
        // 6) 条件删除
34
        list.removeIf(s -> s.startsWith("C"));
35
        System.out.println(list); // []
36
    }
37
}

常见易错点：

remove(int index) 和 remove(Object o) 是重载，List<Integer> 时要特别注意。
边遍历边删除不要直接在 for-each 里 remove，优先用 removeIf 或迭代器。
如果经常在头部插入删除，ArrayList 不如 LinkedList 合适。

1.3 `LinkedList`#

链表结构，首尾插入删除友好。
按索引访问慢。
也实现了 Deque，可当队列/栈用。

1
LinkedList<String> linked = new LinkedList<>();
2
linked.addFirst("first");
3
linked.addLast("last");
4
System.out.println(linked.removeFirst()); // first

1.4 `HashMap` / `HashSet`#

HashMap：键值映射，平均查找 O(1)。
HashSet：基于哈希的去重集合。
两者都支持 remove、clear 等删除方法。

1
import java.util.HashMap;
2
import java.util.HashSet;
3
import java.util.Map;
4
import java.util.Set;
5

6
public class MapSetCrudDemo {
7
    public static void main(String[] args) {
8
        // ---------- Map: 增删改查 ----------
9
        Map<String, Integer> age = new HashMap<>();
10

11
        // 1) 新增
12
        age.put("Alice", 18);
13
        age.put("Bob", 20);
14
        age.putIfAbsent("Alice", 99); // 已存在则不覆盖
15

16
        // 2) 查询
17
        System.out.println(age.get("Alice"));             // 18
18
        System.out.println(age.getOrDefault("Tom", -1));  // -1
19
        System.out.println(age.containsKey("Bob"));       // true
20
        System.out.println(age.containsValue(20));        // true
21

22
        // 3) 修改
23
        age.put("Bob", 21);             // 覆盖旧值
24
        age.replace("Alice", 19);       // 仅当 key 存在时替换
25

26
        // 4) 删除
27
        Integer removed = age.remove("Bob");              // 按 key 删除，返回旧值 21
28
        boolean removedPair = age.remove("Alice", 19);    // key/value 同时匹配才删除
29
        System.out.println(removed);      // 21
30
        System.out.println(removedPair);  // true
31

32
        // 5) 清空
33
        age.clear();
34
        System.out.println(age.isEmpty()); // true
35

36
        // ---------- Set: 去重 + 删除 ----------
37
        Set<String> set = new HashSet<>();
38
        set.add("java");
39
        set.add("java"); // 重复元素不会新增
40
        set.add("go");
41
        set.add("python");
42

43
        // 查询
44
        System.out.println(set.contains("go")); // true
45

46
        // 删除
47
        boolean removedGo = set.remove("go");                   // 按元素删除
48
        set.removeIf(s -> s.startsWith("py"));                  // 条件删除
49
        System.out.println(removedGo);                          // true
50
        System.out.println(set); // [java]（HashSet 顺序不保证）
51

52
        // 清空
53
        set.clear();
54
        System.out.println(set.isEmpty()); // true
55
    }
56
}

删除方法速记：

Map.remove(key)：按 key 删除并返回旧值。
Map.remove(key, value)：key 和 value 同时匹配才删除，返回布尔值。
Set.remove(element)：删除指定元素，返回布尔值。
Set.removeIf(predicate)：按条件批量删除。
Map.clear() / Set.clear()：清空集合。

1.5 `TreeMap` / `TreeSet`#

自动有序（红黑树）。
适合范围查询、有序输出。

1
TreeSet<Integer> tree = new TreeSet<>(List.of(5, 1, 3));
2
System.out.println(tree); // [1, 3, 5]

1.6 `Queue` / `Deque` / `PriorityQueue`#

Queue：FIFO（先进先出）。
Deque：双端队列，可做队列也可做栈。
PriorityQueue：优先级队列（堆），不保证整体有序，只保证堆顶优先。

1.7 `Arrays` 工具类（重点补充）#

Arrays 是数组处理最常用的工具类，核心能力包括排序、比较、查找、填充和拷贝。

1
import java.util.Arrays;
2

3
public class ArraysApiDemo {
4
    public static void main(String[] args) {
5
        int[] a = {5, 2, 9, 1};
6
        int[] b = {1, 2, 5, 9};
7

8
        // 1) 排序
9
        Arrays.sort(a); // [1, 2, 5, 9]
10
        System.out.println(Arrays.toString(a));
11

12
        // 2) 比较（元素和顺序都相同才为 true）
13
        System.out.println(Arrays.equals(a, b)); // true
14

15
        // 3) 二分查找（前提：数组已排序）
16
        int idx = Arrays.binarySearch(a, 5);
17
        System.out.println(idx); // 2
18

19
        // 4) 填充
20
        int[] filled = new int[4];
21
        Arrays.fill(filled, 7); // [7, 7, 7, 7]
22
        System.out.println(Arrays.toString(filled));
23

24
        // 5) 拷贝扩容
25
        int[] copied = Arrays.copyOf(a, 6); // 长度扩成 6，不足补 0
26
        System.out.println(Arrays.toString(copied)); // [1, 2, 5, 9, 0, 0]
27

28
        // 6) 区间排序 [from, to)
29
        int[] part = {9, 4, 7, 1, 8};
30
        Arrays.sort(part, 1, 4); // 仅排序索引 1~3
31
        System.out.println(Arrays.toString(part)); // [9, 1, 4, 7, 8]
32
    }
33
}

使用建议：

Arrays.equals 比较的是值，不是引用地址。
用 binarySearch 前必须先确保有序，否则结果不可靠。
日志打印数组尽量用 Arrays.toString，不要直接打印引用。

1.8 全数据结构 CRUD 速查#

1.8.1 `Array` 的 CRUD#

C（新增）：固定长度，通常是新建更大数组并拷贝。
R（查询）：arr[index]。
U（修改）：arr[index] = newValue。
D（删除）：数组没有“真删除”，需要新建数组并跳过指定元素。

1
import java.util.Arrays;
2

3
public class ArrayCrudDemo {
4
    public static void main(String[] args) {
5
        int[] arr = {10, 20, 30};
6

7
        // C: 新增元素 40（扩容 + 拷贝）
8
        arr = Arrays.copyOf(arr, arr.length + 1);
9
        arr[arr.length - 1] = 40;
10

11
        // R: 查询
12
        System.out.println(arr[1]); // 20
13

14
        // U: 修改
15
        arr[0] = 99;
16

17
        // D: 删除索引 1 的元素
18
        arr = removeAt(arr, 1);
19
        System.out.println(Arrays.toString(arr)); // [99, 30, 40]
20
    }
21

22
    static int[] removeAt(int[] arr, int idx) {
23
        int[] res = new int[arr.length - 1];
24
        System.arraycopy(arr, 0, res, 0, idx);
25
        System.arraycopy(arr, idx + 1, res, idx, arr.length - idx - 1);
26
        return res;
27
    }
28
}

1.8.2 `ArrayList` 的 CRUD#

C：add(e)、add(index, e)。
R：get(index)、contains(e)、indexOf(e)。
U：set(index, e)。
D：remove(index)、remove(obj)、removeIf(...)、clear()。

1
import java.util.ArrayList;
2
import java.util.List;
3

4
public class ArrayListCrudSimpleDemo {
5
    public static void main(String[] args) {
6
        List<String> list = new ArrayList<>();
7

8
        // C
9
        list.add("A");
10
        list.add(1, "B");
11

12
        // R
13
        System.out.println(list.get(0));       // A
14
        System.out.println(list.contains("B"));// true
15

16
        // U
17
        list.set(1, "C");
18

19
        // D
20
        list.remove("A");
21
        list.removeIf(s -> s.startsWith("C"));
22
        System.out.println(list); // []
23
    }
24
}

1.8.3 `LinkedList` 的 CRUD#

C：add/addFirst/addLast。
R：get(index)、getFirst/getLast。
U：set(index, e)。
D：removeFirst/removeLast/remove(index)/remove(obj)/clear。

1
import java.util.LinkedList;
2

3
public class LinkedListCrudDemo {
4
    public static void main(String[] args) {
5
        LinkedList<String> linked = new LinkedList<>();
6

7
        // C
8
        linked.addFirst("B");
9
        linked.addLast("C");
10
        linked.add(0, "A");
11

12
        // R
13
        System.out.println(linked.getFirst()); // A
14
        System.out.println(linked.get(1));     // B
15

16
        // U
17
        linked.set(2, "Z");
18

19
        // D
20
        linked.removeFirst();  // 删除 A
21
        linked.remove("Z");    // 删除值 Z
22
        System.out.println(linked); // [B]
23
    }
24
}

1.8.4 `HashMap` 的 CRUD#

C：put、putIfAbsent。
R：get、getOrDefault、containsKey。
U：put（覆盖）、replace、computeIfPresent。
D：remove(key)、remove(key, value)、clear()。

1
import java.util.HashMap;
2
import java.util.Map;
3

4
public class HashMapCrudDemo {
5
    public static void main(String[] args) {
6
        Map<String, Integer> age = new HashMap<>();
7

8
        // C
9
        age.put("Alice", 18);
10
        age.putIfAbsent("Bob", 20);
11

12
        // R
13
        System.out.println(age.get("Alice")); // 18
14
        System.out.println(age.containsKey("Bob")); // true
15

16
        // U
17
        age.replace("Alice", 19);
18
        age.computeIfPresent("Bob", (k, v) -> v + 1); // 21
19

20
        // D
21
        age.remove("Bob");
22
        age.remove("Alice", 19);
23
        System.out.println(age.isEmpty()); // true
24
    }
25
}

1.8.5 `HashSet` 的 CRUD#

C：add。
R：contains。
U：Set 没有“就地更新”，通常 remove(old) + add(new)。
D：remove、removeIf、clear。

1
import java.util.HashSet;
2
import java.util.Set;
3

4
public class HashSetCrudDemo {
5
    public static void main(String[] args) {
6
        Set<String> set = new HashSet<>();
7

8
        // C
9
        set.add("java");
10
        set.add("go");
11

12
        // R
13
        System.out.println(set.contains("java")); // true
14

15
        // U（模拟更新）
16
        set.remove("go");
17
        set.add("golang");
18

19
        // D
20
        set.remove("java");
21
        set.removeIf(s -> s.startsWith("go"));
22
        System.out.println(set.isEmpty()); // true
23
    }
24
}

1.8.6 `TreeMap` 的 CRUD#

C：put。
R：get、firstKey、lastKey、ceilingKey/floorKey。
U：replace、computeIfPresent。
D：remove、pollFirstEntry、pollLastEntry、clear。

1
import java.util.TreeMap;
2

3
public class TreeMapCrudDemo {
4
    public static void main(String[] args) {
5
        TreeMap<Integer, String> tm = new TreeMap<>();
6

7
        // C
8
        tm.put(100, "A");
9
        tm.put(200, "B");
10
        tm.put(150, "C");
11

12
        // R
13
        System.out.println(tm.get(150));      // C
14
        System.out.println(tm.firstKey());    // 100
15
        System.out.println(tm.ceilingKey(160)); // 200
16

17
        // U
18
        tm.replace(150, "C2");
19

20
        // D
21
        tm.remove(100);
22
        tm.pollLastEntry(); // 删除最大 key
23
        System.out.println(tm); // {150=C2}
24
    }
25
}

1.8.7 `TreeSet` 的 CRUD#

C：add。
R：contains、first/last、ceiling/floor。
U：同 Set，一般删除旧值再新增新值。
D：remove、pollFirst/pollLast、clear。

1
import java.util.TreeSet;
2

3
public class TreeSetCrudDemo {
4
    public static void main(String[] args) {
5
        TreeSet<Integer> ts = new TreeSet<>();
6

7
        // C
8
        ts.add(3);
9
        ts.add(1);
10
        ts.add(2);
11

12
        // R
13
        System.out.println(ts.first());     // 1
14
        System.out.println(ts.ceiling(2));  // 2
15

16
        // U（模拟更新 2 -> 20）
17
        ts.remove(2);
18
        ts.add(20);
19

20
        // D
21
        ts.pollFirst(); // 删除最小
22
        ts.remove(20);
23
        System.out.println(ts); // [3]
24
    }
25
}

1.8.8 `Queue` 的 CRUD（FIFO）#

C：offer。
R：peek、element（空队列会抛异常）。
U：Queue 无随机更新，通常出队后再入队。
D：poll、remove(obj)、clear。

1
import java.util.ArrayDeque;
2
import java.util.Queue;
3

4
public class QueueCrudDemo {
5
    public static void main(String[] args) {
6
        Queue<String> q = new ArrayDeque<>();
7

8
        // C
9
        q.offer("A");
10
        q.offer("B");
11

12
        // R
13
        System.out.println(q.peek()); // A
14

15
        // U（把队头 A 更新为 A1）
16
        String head = q.poll();
17
        q.offer(head + "1");
18

19
        // D
20
        q.remove("B");
21
        q.poll(); // 删除队头 A1
22
        System.out.println(q.isEmpty()); // true
23
    }
24
}

1.8.9 `Deque` 的 CRUD（双端）#

C：offerFirst/offerLast。
R：peekFirst/peekLast。
U：删除旧值再从头/尾插入新值。
D：pollFirst/pollLast/remove/clear。

1
import java.util.ArrayDeque;
2
import java.util.Deque;
3

4
public class DequeCrudDemo {
5
    public static void main(String[] args) {
6
        Deque<String> dq = new ArrayDeque<>();
7

8
        // C
9
        dq.offerFirst("B");
10
        dq.offerFirst("A");
11
        dq.offerLast("C");
12

13
        // R
14
        System.out.println(dq.peekFirst()); // A
15
        System.out.println(dq.peekLast());  // C
16

17
        // U（更新尾部 C -> Z）
18
        dq.pollLast();
19
        dq.offerLast("Z");
20

21
        // D
22
        dq.pollFirst();
23
        dq.remove("B");
24
        System.out.println(dq); // [Z]
25
    }
26
}

1.8.10 `PriorityQueue` 的 CRUD（优先级队列）#

C：offer。
R：peek（看堆顶）、contains。
U：元素优先级变化后，通常 remove(old) + offer(new)。
D：poll、remove(obj)、clear。

1
import java.util.Comparator;
2
import java.util.PriorityQueue;
3

4
record Task(String name, int priority) {}
5

6
public class PriorityQueueCrudDemo {
7
    public static void main(String[] args) {
8
        PriorityQueue<Task> pq =
9
            new PriorityQueue<>(Comparator.comparingInt(Task::priority));
10

11
        // C
12
        pq.offer(new Task("backup", 3));
13
        pq.offer(new Task("hotfix", 1));
14

15
        // R
16
        System.out.println(pq.peek()); // hotfix
17

18
        // U（backup 优先级从 3 改为 0）
19
        pq.removeIf(t -> t.name().equals("backup"));
20
        pq.offer(new Task("backup", 0));
21

22
        // D
23
        pq.poll(); // 删除最高优先级元素
24
        pq.removeIf(t -> t.name().equals("hotfix"));
25
        System.out.println(pq.isEmpty()); // true
26
    }
27
}

1.8.11 `Arrays` 在 CRUD 中的辅助角色#

Arrays 不是容器本身，但它常用于数组型数据的 C/R/U/D 辅助操作：

C：copyOf 扩容新增。
R：binarySearch（有序数组）。
U：fill 批量改值。
D：常用 copyOfRange + System.arraycopy 配合实现删除。

2. Queue 接口速查（重点）#

最常用实现：ArrayDeque、LinkedList。

2.1 核心方法和行为#

入队：offer(e)，成功返回 true。
出队：poll()，队空返回 null。
看队头：peek()，队空返回 null。
判空：isEmpty()。
大小：size()。
异常版本：add/remove/element，队空或失败时会抛异常。

2.2 完整示例（`isEmpty + offer + poll + peek`）#

1
import java.util.ArrayDeque;
2
import java.util.Queue;
3

4
public class QueueApiDemo {
5
    public static void main(String[] args) {
6
        Queue<String> queue = new ArrayDeque<>();
7

8
        System.out.println(queue.isEmpty()); // true
9
        System.out.println(queue.size());    // 0
10

11
        queue.offer("task-1");
12
        queue.offer("task-2");
13
        queue.offer("task-3");
14

15
        System.out.println(queue.peek());    // task-1（只看不取）
16
        System.out.println(queue.size());    // 3
17

18
        while (!queue.isEmpty()) {
19
            String task = queue.poll();      // 取并删除队头
20
            System.out.println("processing: " + task);
21
        }
22

23
        System.out.println(queue.poll());    // null（空队列安全返回）
24
        System.out.println(queue.isEmpty()); // true
25
    }
26
}

2.3 `poll` 和 `remove` 的区别#

1
import java.util.ArrayDeque;
2
import java.util.Queue;
3

4
public class QueueRemoveVsPoll {
5
    public static void main(String[] args) {
6
        Queue<Integer> q = new ArrayDeque<>();
7

8
        System.out.println(q.poll()); // null
9

10
        try {
11
            System.out.println(q.remove()); // 抛 NoSuchElementException
12
        } catch (Exception e) {
13
            System.out.println(e.getClass().getSimpleName());
14
        }
15
    }
16
}

结论：业务里更推荐 poll()，避免空队列异常中断。

3. Deque 双端队列接口（实用）#

Deque 同时支持头尾操作，接口非常丰富。

3.1 常用方法#

头部入队：offerFirst(e)
尾部入队：offerLast(e)
头部出队：pollFirst()
尾部出队：pollLast()
栈语义：push(e) / pop()

3.2 示例：双端任务池#

1
import java.util.ArrayDeque;
2
import java.util.Deque;
3

4
public class DequeDemo {
5
    public static void main(String[] args) {
6
        Deque<String> deque = new ArrayDeque<>();
7

8
        deque.offerLast("normal-1");
9
        deque.offerLast("normal-2");
10
        deque.offerFirst("urgent-0");
11

12
        System.out.println(deque.pollFirst()); // urgent-0
13
        System.out.println(deque.pollLast());  // normal-2
14

15
        deque.push("stack-A");
16
        deque.push("stack-B");
17
        System.out.println(deque.pop());       // stack-B
18
    }
19
}

4. PriorityQueue 接口速查（重点）#

PriorityQueue 是堆结构，不是普通 FIFO 队列。

4.1 核心特性#

默认是小顶堆（最小值先出）。
可传比较器变成大顶堆或自定义优先级。
常用方法：offer、peek、poll、isEmpty、size。

4.2 示例一：默认最小堆#

1
import java.util.PriorityQueue;
2

3
public class PriorityQueueMinHeapDemo {
4
    public static void main(String[] args) {
5
        PriorityQueue<Integer> pq = new PriorityQueue<>();
6
        pq.offer(5);
7
        pq.offer(1);
8
        pq.offer(3);
9

10
        while (!pq.isEmpty()) {
11
            System.out.println(pq.poll()); // 1, 3, 5
12
        }
13
    }
14
}

4.3 示例二：最大堆（自定义比较器）#

1
import java.util.Comparator;
2
import java.util.PriorityQueue;
3

4
public class PriorityQueueMaxHeapDemo {
5
    public static void main(String[] args) {
6
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
7
        maxHeap.offer(5);
8
        maxHeap.offer(1);
9
        maxHeap.offer(3);
10

11
        System.out.println(maxHeap.peek()); // 5
12
        System.out.println(maxHeap.poll()); // 5
13
        System.out.println(maxHeap.poll()); // 3
14
        System.out.println(maxHeap.poll()); // 1
15
    }
16
}

4.4 示例三：按任务优先级调度#

1
import java.util.PriorityQueue;
2

3
class Task {
4
    String name;
5
    int priority; // 数值越小优先级越高
6

7
    Task(String name, int priority) {
8
        this.name = name;
9
        this.priority = priority;
10
    }
11
}
12

13
public class PriorityTaskDemo {
14
    public static void main(String[] args) {
15
        PriorityQueue<Task> pq = new PriorityQueue<>((a, b) -> a.priority - b.priority);
16

17
        pq.offer(new Task("backup", 3));
18
        pq.offer(new Task("hotfix", 1));
19
        pq.offer(new Task("report", 2));
20

21
        while (!pq.isEmpty()) {
22
            Task t = pq.poll();
23
            System.out.println(t.name + " -> p" + t.priority);
24
        }
25
    }
26
}

输出顺序是：hotfix -> report -> backup。

5. 高频“快捷接口”补充（Map / List / Set / Arrays）#

5.1 `Map` 常用快捷接口#

1
import java.util.*;
2

3
public class MapQuickApiDemo {
4
    public static void main(String[] args) {
5
        Map<String, Integer> freq = new HashMap<>();
6

7
        freq.merge("java", 1, Integer::sum);
8
        freq.merge("java", 1, Integer::sum);
9
        freq.merge("go", 1, Integer::sum);
10
        System.out.println(freq.getOrDefault("java", 0)); // 2
11

12
        freq.remove("go");                 // 按 key 删除
13
        freq.remove("java", 99);           // key/value 不匹配，删除失败
14
        freq.remove("java", 2);            // key/value 匹配，删除成功
15

16
        Map<String, List<String>> group = new HashMap<>();
17
        group.computeIfAbsent("RD", k -> new ArrayList<>()).add("Alice");
18
        group.computeIfAbsent("RD", k -> new ArrayList<>()).add("Bob");
19

20
        System.out.println(group); // {RD=[Alice, Bob]}
21
    }
22
}

5.2 `List` 常用快捷接口#

1
import java.util.*;
2

3
public class ListQuickApiDemo {
4
    public static void main(String[] args) {
5
        List<Integer> nums = new ArrayList<>(List.of(5, 1, 2, 8, 3, 2));
6

7
        nums.add(0, 99);                    // 索引插入
8
        nums.remove(1);                     // 按索引删除
9
        nums.remove(Integer.valueOf(2));    // 按元素值删除（只删第一个匹配）
10

11
        nums.removeIf(n -> n % 2 == 0);      // 删除偶数
12
        nums.replaceAll(n -> n * 10);        // 每个元素乘 10
13
        nums.sort(Integer::compareTo);       // 升序排序
14

15
        System.out.println(nums);
16
    }
17
}

5.3 `Stream` 一行管道示例#

1
import java.util.List;
2
import java.util.Map;
3
import java.util.stream.Collectors;
4

5
public class StreamDemo {
6
    public static void main(String[] args) {
7
        List<String> words = List.of("java", "go", "java", "rust", "go", "java");
8

9
        Map<String, Long> countMap = words.stream()
10
            .collect(Collectors.groupingBy(w -> w, Collectors.counting()));
11

12
        System.out.println(countMap); // {java=3, go=2, rust=1}
13
    }
14
}

5.4 `Arrays` 常用快捷接口#

1
import java.util.Arrays;
2

3
public class ArraysQuickApiDemo {
4
    public static void main(String[] args) {
5
        int[] arr = {4, 2, 8, 1};
6

7
        Arrays.sort(arr);
8
        System.out.println(Arrays.toString(arr)); // [1, 2, 4, 8]
9

10
        int[] another = {1, 2, 4, 8};
11
        System.out.println(Arrays.equals(arr, another)); // true
12
    }
13
}

5.5 `Set` 常用快捷接口（含删除）#

1
import java.util.HashSet;
2
import java.util.Set;
3

4
public class SetQuickApiDemo {
5
    public static void main(String[] args) {
6
        Set<String> tags = new HashSet<>();
7
        tags.add("java");
8
        tags.add("go");
9
        tags.add("python");
10
        tags.add("java"); // 重复无效
11

12
        tags.remove("go");                        // 删除单个元素
13
        tags.removeIf(t -> t.startsWith("py"));   // 条件删除
14
        tags.retainAll(Set.of("java", "rust"));   // 只保留交集
15

16
        System.out.println(tags); // [java]（顺序不保证）
17
    }
18
}

6. 综合案例：普通队列 + 优先队列#

6.1 场景说明#

场景：系统里有普通任务和紧急任务。
处理策略：先处理紧急任务，再处理普通任务。

6.2 代码示例#

1
import java.util.ArrayDeque;
2
import java.util.Comparator;
3
import java.util.PriorityQueue;
4
import java.util.Queue;
5

6
class Job {
7
    String name;
8
    int priority; // 越小越紧急
9

10
    Job(String name, int priority) {
11
        this.name = name;
12
        this.priority = priority;
13
    }
14
}
15

16
public class SchedulerDemo {
17
    public static void main(String[] args) {
18
        Queue<Job> normalQueue = new ArrayDeque<>();
19
        PriorityQueue<Job> urgentQueue =
20
            new PriorityQueue<>(Comparator.comparingInt(j -> j.priority));
21

22
        normalQueue.offer(new Job("daily-report", 99));
23
        normalQueue.offer(new Job("sync-data", 99));
24
        urgentQueue.offer(new Job("hotfix-prod", 1));
25
        urgentQueue.offer(new Job("security-patch", 2));
26

27
        while (!urgentQueue.isEmpty() || !normalQueue.isEmpty()) {
28
            Job current = !urgentQueue.isEmpty() ? urgentQueue.poll() : normalQueue.poll();
29
            System.out.println("run: " + current.name + ", p=" + current.priority);
30
        }
31
    }
32
}

6.3 适用场景#

这个模式在“工单系统、消息处理、重试队列”里非常常见。

7. 常见坑#

7.1 队列行为相关#

PriorityQueue 遍历结果不是全局有序，只有 poll 出来的顺序有保障。
Queue 空队列场景下尽量用 poll/peek，少用 remove/element。

7.2 集合与并发相关#

List.of/Set.of/Map.of 是不可变集合，不能增删。
并发环境别直接用 ArrayDeque/HashMap，要换并发容器。

8. 总结#

8.1 三条速记#

如果你只想记最关键的：

FIFO 用 Queue：offer + poll + peek + isEmpty。
有优先级用 PriorityQueue：比较器决定出队顺序。
统计和分组优先用 merge、computeIfAbsent、groupingBy。

Lovely firefly!

Java基本数据结构与高频接口实战手册

1. Java 基本数据结构怎么选#

1.1 Array（数组）#

1.2 ArrayList#

1.3 LinkedList#

1.4 HashMap / HashSet#

1.5 TreeMap / TreeSet#

1.6 Queue / Deque / PriorityQueue#

1.7 Arrays 工具类（重点补充）#