SuperJeason

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

Fri, 13 Feb 2026 00:00:00 GMT

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。

LangChain4j Agent 开发指南:用 Java 构建智能应用

Sun, 08 Feb 2026 00:00:00 GMT

前言#

随着大语言模型(LLM)的快速发展,越来越多的开发者希望将 AI 能力集成到自己的应用中。LangChain4j 是 LangChain 的 Java 实现版本,为 Java 开发者提供了构建 AI 应用的完整工具链。

本文将从零开始,介绍如何使用 LangChain4j + Spring Boot 构建一个功能完整的 AI Agent,包括:

✅ AI Services 构建模式
✅ Function Calling 工具系统
✅ 对话记忆管理
✅ 流式响应处理
✅ 对话历史持久化

什么是 LangChain4j?#

LangChain4j 是一个用于开发由大语言模型驱动的应用程序的 Java 框架,提供了以下核心能力:

统一的 LLM 抽象: 支持 OpenAI、Azure OpenAI、Google Gemini、Claude 等多种模型
AI Services: 通过接口 + 注解定义 AI 能力
Function Calling: 让 AI 自动调用 Java 方法获取数据
对话记忆: 管理对话上下文,支持多种存储策略
流式输出: 实时流式返回 AI 响应
LangChain4j Layered Architecture

LangChain4j 架构图#

graph TB subgraph "应用层" APP["Spring Boot 应用"] end subgraph "LangChain4j 核心" AI_SERVICE["AI Services (接口 + 注解)"] MEMORY["对话记忆 (Chat Memory)"] TOOLS["工具系统 (Function Calling)"] end subgraph "LLM 层" OPENAI["OpenAI"] AZURE["Azure OpenAI"] GEMINI["Google Gemini"] CLAUDE["Claude"] end subgraph "工具层" DB["数据库查询"] API["外部 API"] FILE["文件处理"] CUSTOM["自定义工具"] end APP --> AI_SERVICE AI_SERVICE --> MEMORY AI_SERVICE --> TOOLS AI_SERVICE --> OPENAI AI_SERVICE --> AZURE AI_SERVICE --> GEMINI AI_SERVICE --> CLAUDE TOOLS --> DB TOOLS --> API TOOLS --> FILE TOOLS --> CUSTOM style AI_SERVICE fill:#4CAF50,color:#fff style MEMORY fill:#2196F3,color:#fff style TOOLS fill:#FF9800,color:#fff

快速开始#

1. 添加依赖#

在 pom.xml 中添加 LangChain4j 依赖:

1
<dependencies>
2
    <!-- LangChain4j Spring Boot Starter -->
3
    <dependency>
4
        <groupId>dev.langchain4j</groupId>
5
        <artifactId>langchain4j-spring-boot-starter</artifactId>
6
        <version>0.35.0</version>
7
    </dependency>
8

9
    <!-- OpenAI 集成 (可替换为其他模型提供商) -->
10
    <dependency>
11
        <groupId>dev.langchain4j</groupId>
12
        <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
13
        <version>0.35.0</version>
14
    </dependency>
15
</dependencies>

显示更多显示更少

2. 配置 LLM 连接#

在 application.yml 中配置模型参数:

1
langchain4j:
2
  open-ai:
3
    chat-model:
4
      api-key: ${OPENAI_API_KEY}
5
      base-url: https://api.openai.com/v1  # 或自定义 API 端点
6
      model-name: gpt-4o-mini
7
      temperature: 0.7
8
      timeout: 60s

💡 提示: 可以使用兼容 OpenAI API 的其他模型(如 GLM-4、Qwen、DeepSeek 等),只需修改 base-url 和 model-name。

核心概念 Services#

什么是 AI Services?#

AI Services 是 LangChain4j 的核心抽象,通过 接口 + 注解 的方式定义 AI 能力,类似于 Spring Data JPA 的 Repository 模式。

定义 AI Agent 接口#

1
import dev.langchain4j.service.SystemMessage;
2
import dev.langchain4j.service.UserMessage;
3
import dev.langchain4j.service.MemoryId;
4
import dev.langchain4j.service.TokenStream;
5

6
public interface DataAnalystAgent {
7

8
    @SystemMessage("""
9
        你是一个数据分析助手。你的职责是:
10
        1. 根据用户问题,选择合适的工具查询数据
11
        2. 分析数据趋势,识别异常模式
12
        3. 生成专业的分析报告
13

14
        【可用工具】
15
        - queryStatistics: 查询统计数据
16
        - analyzeTrend: 分析趋势
17
        - generateReport: 生成报告
18

19
        【工作流程】
20
        1. 理解用户问题,确定需要哪些数据
21
        2. 依次调用工具收集原始数据
22
        3. 进行分析和总结
23
        4. 用专业但易懂的语言回复用户
24
        """)
25
    TokenStream chat(
26
        @MemoryId String conversationId,
27
        @UserMessage String question
28
    );
29
}

显示更多显示更少

注解说明#

@SystemMessage: 定义 AI 的系统提示词(角色、能力、工作流程)
@UserMessage: 标记用户输入参数
@MemoryId: 标识对话会话 ID(用于记忆管理)
返回值 TokenStream: 流式返回 AI 响应

Function Calling:让 AI 调用 Java 方法#

什么是 Function Calling?#

Function Calling 允许 AI 在回答问题时,自动调用 Java 方法获取实时数据。

Tool Calling Workflow

Function Calling 工作流程#

sequenceDiagram participant User as 用户 participant Agent as AI Agent participant LangChain as LangChain4j participant Tool as Java 工具方法 participant DB as 数据源 User->>Agent: 最近7天的数据趋势如何? Agent->>Agent: 分析问题:需要统计数据 Agent->>LangChain: 请求调用 queryStatistics LangChain->>Tool: 执行 Java 方法 queryStatistics("2024-01-25", "2024-01-31") Tool->>DB: 查询数据库 DB-->>Tool: 返回原始数据 Tool-->>LangChain: 返回格式化结果 "总数:100, 平均值:85.5" LangChain-->>Agent: 工具返回数据 Agent->>Agent: 综合分析数据 Agent-->>User: 最近7天共100条记录, 平均值为85.5,呈稳定趋势

定义工具类#

使用 @Tool 注解定义可被 AI 调用的方法:

1
import dev.langchain4j.agent.tool.Tool;
2
import dev.langchain4j.agent.tool.P;
3
import lombok.RequiredArgsConstructor;
4
import org.springframework.stereotype.Component;
5

6
@Component
7
@RequiredArgsConstructor
8
public class DataQueryTools {
9

10
    private final DataRepository dataRepository;
11

12
    @Tool("查询指定时间范围内的统计数据")
13
    public String queryStatistics(
14
        @P("开始日期,格式 YYYY-MM-DD") String startDate,
15
        @P("结束日期,格式 YYYY-MM-DD") String endDate
16
    ) {
17
        // 查询数据库
18
        List<DataRecord> records = dataRepository.findByDateBetween(startDate, endDate);
19

20
        // 统计分析
21
        long totalCount = records.size();
22
        double avgValue = records.stream()
23
            .mapToDouble(DataRecord::getValue)
24
            .average()
25
            .orElse(0.0);
26

27
        // 返回格式化结果
28
        return String.format(
29
            "时间范围: %s 至 %s\n" +
30
            "记录总数: %d 条\n" +
31
            "平均值: %.2f",
32
            startDate, endDate, totalCount, avgValue
33
        );
34
    }
35

36
    @Tool("查询最近N天的趋势数据")
37
    public String queryTrend(
38
        @P("查询天数,例如 7 表示最近7天") int days
39
    ) {
40
        LocalDate endDate = LocalDate.now();
41
        LocalDate startDate = endDate.minusDays(days);
42

43
        List<DataRecord> records = dataRepository.findByDateBetween(startDate, endDate);
44

45
        // 按日期分组统计
46
        Map<LocalDate, Double> dailyAvg = records.stream()
47
            .collect(Collectors.groupingBy(
48
                DataRecord::getDate,
49
                Collectors.averagingDouble(DataRecord::getValue)
50
            ));
51

52
        // 格式化输出
53
        StringBuilder result = new StringBuilder("每日趋势:\n");
54
        dailyAvg.entrySet().stream()
55
            .sorted(Map.Entry.comparingByKey())
56
            .forEach(entry -> {
57
                result.append(String.format(
58
                    "%s: %.2f\n",
59
                    entry.getKey(), entry.getValue()
60
                ));
61
            });
62

63
        return result.toString();
64
    }
65
}

显示更多显示更少

注解说明#

@Tool("工具描述"): 告诉 AI 这个方法的用途,AI 会根据描述决定是否调用
@P("参数说明"): 描述参数的含义和格式要求,帮助 AI 正确传参

⚠️ 重要: 工具描述和参数说明要清晰准确,这直接影响 AI 的调用准确率。

配置 AI Agent Bean#

使用 AiServices 构建器将接口、模型、工具组装起来:

1
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
2
import dev.langchain4j.model.chat.StreamingChatLanguageModel;
3
import dev.langchain4j.model.openai.OpenAiStreamingChatModel;
4
import dev.langchain4j.service.AiServices;
5
import org.springframework.context.annotation.Bean;
6
import org.springframework.context.annotation.Configuration;
7

8
@Configuration
9
@RequiredArgsConstructor
10
public class LangChain4jConfig {
11

12
    private final DataQueryTools dataQueryTools;
13
    private final AnalysisTools analysisTools;
14

15
    @Value("${langchain4j.open-ai.chat-model.api-key}")
16
    private String apiKey;
17

18
    @Value("${langchain4j.open-ai.chat-model.base-url}")
19
    private String baseUrl;
20

21
    @Value("${langchain4j.open-ai.chat-model.model-name}")
22
    private String modelName;
23

24
    @Bean
25
    public StreamingChatLanguageModel streamingChatLanguageModel() {
26
        return OpenAiStreamingChatModel.builder()
27
            .apiKey(apiKey)
28
            .baseUrl(baseUrl)
29
            .modelName(modelName)
30
            .temperature(0.7)
31
            .timeout(Duration.ofSeconds(60))
32
            .build();
33
    }
34

35
    @Bean
36
    public DataAnalystAgent dataAnalystAgent(
37
        StreamingChatLanguageModel model
38
    ) {
39
        return AiServices.builder(DataAnalystAgent.class)
40
            .streamingChatLanguageModel(model)
41
            .chatMemoryProvider(memoryId ->
42
                MessageWindowChatMemory.withMaxMessages(20)  // 保留最近20条消息
43
            )
44
            .tools(dataQueryTools, analysisTools)  // 注册工具
45
            .build();
46
    }
47
}

显示更多显示更少

配置说明#

streamingChatLanguageModel(): 配置流式 LLM 客户端
chatMemoryProvider(): 配置对话记忆,保留最近 N 条消息
tools(): 注册工具类,AI 可以调用这些工具中的 @Tool 方法

对话记忆管理#

为什么需要对话记忆?#

AI 需要理解上下文才能进行连贯的对话。例如:

1
用户: 查询最近7天的数据
2
AI: [返回数据统计]
3

4
用户: 趋势如何?  👈 AI 需要记住之前讨论的是"最近7天"
5
AI: 趋势呈上升态势...

内置记忆策略#

LangChain4j 提供多种记忆实现:

记忆类型	说明	适用场景
`MessageWindowChatMemory`	保留最近 N 条消息	短对话,内存有限
`TokenWindowChatMemory`	保留最近 N 个 Token	精确控制上下文长度
`ChatMemory` (自定义)	从数据库加载历史	长期对话,需持久化

对话记忆工作原理#

graph LR subgraph "第1轮对话" U1["用户: 查询最近7天数据"] A1["AI: 返回统计结果"] end subgraph "记忆存储" MEM["MessageWindowChatMemory 保留最近20条消息"] end subgraph "第2轮对话" U2["用户: 趋势如何?"] A2["AI: 基于上文 分析趋势"] end U1 --> MEM A1 --> MEM MEM --> U2 U2 --> A2 style MEM fill:#2196F3,color:#fff

自定义持久化记忆#

通过 chatMemoryProvider 实现从数据库加载历史:

1
@Bean
2
public DataAnalystAgent dataAnalystAgent(
3
    StreamingChatLanguageModel model,
4
    ChatHistoryService chatHistoryService
5
) {
6
    return AiServices.builder(DataAnalystAgent.class)
7
        .streamingChatLanguageModel(model)
8
        .chatMemoryProvider(memoryId -> {
9
            MessageWindowChatMemory memory = MessageWindowChatMemory.withMaxMessages(20);
10

11
            // 从数据库加载历史消息
12
            List<ChatMessage> history = chatHistoryService.loadRecentMessages(
13
                memoryId, 20
14
            );
15

16
            // 恢复到内存
17
            for (ChatMessage msg : history) {
18
                if ("user".equals(msg.getRole())) {
19
                    memory.add(UserMessage.from(msg.getContent()));
20
                } else if ("assistant".equals(msg.getRole())) {
21
                    memory.add(AiMessage.from(msg.getContent()));
22
                }
23
            }
24

25
            return memory;
26
        })
27
        .tools(dataQueryTools, analysisTools)
28
        .build();
29
}

显示更多显示更少

流式响应处理#

为什么需要流式响应?#

流式响应可以让用户实时看到 AI 的生成过程,类似 ChatGPT 的打字效果,提升用户体验。

实现流式接口#

使用 Server-Sent Events (SSE) 实现流式传输:

1
import org.springframework.http.MediaType;
2
import org.springframework.http.codec.ServerSentEvent;
3
import org.springframework.web.bind.annotation.*;
4
import reactor.core.publisher.Flux;
5

6
@RestController
7
@RequestMapping("/api/v1/analyst")
8
@RequiredArgsConstructor
9
public class AnalystController {
10

11
    private final DataAnalystAgent agent;
12
    private final ChatHistoryService chatHistoryService;
13

14
    @PostMapping(value = "/chat-stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
15
    public Flux<ServerSentEvent<String>> chatStream(
16
        @RequestParam String question,
17
        @RequestParam String conversationId
18
    ) {
19
        return Flux.create(sink -> {
20
            try {
21
                TokenStream tokenStream = agent.chat(conversationId, question);
22
                StringBuilder fullResponse = new StringBuilder();
23

24
                tokenStream
25
                    .onNext(token -> {
26
                        // 实时推送每个 Token
27
                        fullResponse.append(token);
28
                        ServerSentEvent<String> event = ServerSentEvent.<String>builder()
29
                            .event("message")
30
                            .data(token)
31
                            .build();
32
                        sink.next(event);
33
                    })
34
                    .onToolExecuted(toolExecution -> {
35
                        // 推送工具调用信息
36
                        String toolInfo = String.format(
37
                            "[工具调用: %s]",
38
                            toolExecution.request().name()
39
                        );
40
                        ServerSentEvent<String> event = ServerSentEvent.<String>builder()
41
                            .event("tool")
42
                            .data(toolInfo)
43
                            .build();
44
                        sink.next(event);
45
                    })
46
                    .onComplete(response -> {
47
                        // 保存对话历史
48
                        chatHistoryService.saveMessage(
49
                            conversationId, "user", question
50
                        );
51
                        chatHistoryService.saveMessage(
52
                            conversationId, "assistant", fullResponse.toString()
53
                        );
54

55
                        // 发送完成事件
56
                        ServerSentEvent<String> event = ServerSentEvent.<String>builder()
57
                            .event("done")
58
                            .data("")
59
                            .build();
60
                        sink.next(event);
61
                        sink.complete();
62
                    })
63
                    .onError(error -> {
64
                        // 错误处理
65
                        ServerSentEvent<String> event = ServerSentEvent.<String>builder()
66
                            .event("error")
67
                            .data("服务暂时不可用")
68
                            .build();
69
                        sink.next(event);
70
                        sink.error(error);
71
                    })
72
                    .start();
73

74
            } catch (Exception e) {
75
                sink.error(e);
76
            }
77
        });
78
    }
79
}

显示更多显示更少

流式事件说明#

事件类型	说明	数据内容
`message`	AI 生成的文本片段	单个 Token 或词组
`tool`	工具调用通知	工具名称
`done`	流式输出完成	空字符串
`error`	错误发生	错误信息

高级特性:多工具协作#

场景:生成数据分析报告#

假设我们需要 AI 完成以下任务:

查询最近 7 天的数据
分析趋势
检测异常
生成可视化图表
组装完整报告

AI 自动编排工作流程#

定义多个工具类#

数据查询工具:

1
@Component
2
@RequiredArgsConstructor
3
public class DataQueryTools {
4
    @Tool("查询统计数据")
5
    public String queryStatistics(String startDate, String endDate) {
6
        // 返回统计数据
7
    }
8
}

数据分析工具:

1
@Component
2
public class AnalysisTools {
3
    @Tool("分析趋势是上升、下降还是稳定")
4
    public String analyzeTrend(String trendData) {
5
        // 返回趋势分析结果
6
    }
7

8
    @Tool("检测异常峰值")
9
    public String detectAnomalies(String dailyData) {
10
        // 返回异常检测结果
11
    }
12
}

报告生成工具:

1
@Component
2
public class ReportTools {
3
    @Tool("生成 Markdown 格式的分析报告")
4
    public String generateMarkdownReport(
5
        String title,
6
        String statistics,
7
        String trendAnalysis,
8
        String anomalies,
9
        String conclusions
10
    ) {
11
        return String.format("""
12
            # %s
13

14
            ## 📊 统计数据概览
15
            %s
16

17
            ## 📈 趋势分析
18
            %s
19

20
            ## ⚠️ 异常检测
21
            %s
22

23
            ## 💡 结论与建议
24
            %s
25
            """,
26
            title, statistics, trendAnalysis, anomalies, conclusions
27
        );
28
    }
29

30
    @Tool("生成趋势折线图(Mermaid 格式)")
31
    public String generateTrendChart(String trendData) {
32
        // 解析数据并生成 Mermaid 图表代码
33
    }
34
}

显示更多显示更少

AI 自动编排执行#

在 System Message 中指导 AI 的工作流程:

1
@SystemMessage("""
2
    你是数据分析助手。当用户要求生成报告时,请按以下流程操作:
3

4
    1. 调用 queryStatistics 查询原始数据
5
    2. 调用 analyzeTrend 分析趋势
6
    3. 调用 detectAnomalies 检测异常
7
    4. 调用 generateTrendChart 生成图表
8
    5. 调用 generateMarkdownReport 组装报告
9
    6. 将完整报告返回给用户
10

11
    重要规则:
12
    - 必须先查询数据,再进行分析
13
    - 图表数据必须来自查询结果,不要编造
14
    - 报告要包含图表可视化
15
    """)
16
TokenStream chat(@MemoryId String conversationId, @UserMessage String question);

显示更多显示更少

用户输入:

1
生成最近7天的数据分析报告

AI 执行流程:

1
1. [工具调用: queryStatistics] → 获取统计数据
2
2. [工具调用: analyzeTrend] → 分析趋势
3
3. [工具调用: detectAnomalies] → 检测异常
4
4. [工具调用: generateTrendChart] → 生成图表
5
5. [工具调用: generateMarkdownReport] → 组装报告
6
6. 返回完整的 Markdown 报告(含图表)

最佳实践#

1. System Prompt 设计#

✅ 好的 System Prompt:

1
@SystemMessage("""
2
    你是数据分析助手。职责:
3
    1. 查询数据: 使用 queryStatistics 工具
4
    2. 分析趋势: 使用 analyzeTrend 工具
5
    3. 生成报告: 使用 generateReport 工具
6

7
    工作流程:
8
    1. 理解用户问题
9
    2. 依次调用工具
10
    3. 综合分析结果
11
    4. 用专业语言回复
12

13
    重要规则:
14
    - 先查询数据,再分析
15
    - 数字保留2位小数
16
    - 不要编造数据
17
    """)

显示更多显示更少

❌ 差的 System Prompt:

1
@SystemMessage("你是助手,帮用户查询数据")  // 太简单,AI 不知道如何操作

2. 工具粒度划分#

✅ 合理拆分:

queryStatistics: 查询统计数据
analyzeTrend: 分析趋势
generateReport: 生成报告

❌ 过度耦合:

queryAndAnalyze: 一个方法做所有事情(AI 无法灵活组合)

3. 参数规范设计#

✅ 清晰的参数说明:

1
@Tool("查询统计数据")
2
public String queryStatistics(
3
    @P("开始日期,格式 YYYY-MM-DD,例如 2024-01-01") String startDate,
4
    @P("结束日期,格式 YYYY-MM-DD,例如 2024-01-07") String endDate
5
)

❌ 模糊的参数说明:

1
@Tool("查询统计数据")
2
public String queryStatistics(
3
    @P("开始日期") String startDate,  // 格式不明确,AI 可能传错
4
    @P("结束日期") String endDate
5
)

4. 错误处理#

在工具方法中添加异常处理,返回友好的错误信息:

1
@Tool("查询统计数据")
2
public String queryStatistics(String startDate, String endDate) {
3
    try {
4
        LocalDate start = LocalDate.parse(startDate);
5
        LocalDate end = LocalDate.parse(endDate);
6

7
        if (end.isBefore(start)) {
8
            return "错误: 结束日期不能早于开始日期";
9
        }
10

11
        // 执行查询...
12

13
    } catch (DateTimeParseException e) {
14
        return "错误: 日期格式不正确,请使用 YYYY-MM-DD 格式";
15
    } catch (Exception e) {
16
        return "错误: 查询失败,请稍后重试";
17
    }
18
}

显示更多显示更少

5. 日志记录#

在工具方法中添加日志,方便调试:

1
@Tool("查询统计数据")
2
public String queryStatistics(String startDate, String endDate) {
3
    log.info("工具调用: queryStatistics - {} 到 {}", startDate, endDate);
4

5
    // 执行查询...
6

7
    log.info("查询完成,返回 {} 条记录", records.size());
8
    return result;
9
}

完整系统架构#

将所有组件整合在一起,完整的 LangChain4j Agent 系统架构如下:

graph TB subgraph "客户端层" Browser["浏览器/前端应用"] end subgraph "Spring Boot 应用" Controller["Controller 流式 SSE 接口"] Agent["AI Agent (AI Services 接口)"] Config["LangChain4j 配置 注册工具和记忆"] end subgraph "LangChain4j 核心" Memory["对话记忆 MessageWindowChatMemory"] ToolRegistry["工具注册表 Function Calling"] LLMClient["LLM 客户端 StreamingChatLanguageModel"] end subgraph "工具层" Tool1["DataQueryTools @Tool 查询数据"] Tool2["AnalysisTools @Tool 分析趋势"] Tool3["ReportTools @Tool 生成报告"] end subgraph "数据层" DB["数据库 MySQL/PostgreSQL"] Redis["Redis 对话历史缓存"] end subgraph "AI 服务" OpenAI["OpenAI API gpt-4o-mini"] end Browser -->|"POST /chat-stream"| Controller Controller --> Agent Agent --> Memory Agent --> ToolRegistry Agent --> LLMClient ToolRegistry --> Tool1 ToolRegistry --> Tool2 ToolRegistry --> Tool3 Tool1 --> DB Memory --> Redis LLMClient --> OpenAI Agent -->|"SSE 流式响应"| Controller Controller -->|"SSE 事件流"| Browser style Agent fill:#4CAF50,color:#fff style Memory fill:#2196F3,color:#fff style ToolRegistry fill:#FF9800,color:#fff style LLMClient fill:#9C27B0,color:#fff

完整示例:数据分析 Agent#

以下是一个完整的 数据分析 Agent 示例,展示所有核心特性的集成:

1. 定义 Agent 接口#

1
public interface DataAnalystAgent {
2
    @SystemMessage("""
3
        你是数据分析助手。职责:
4
        1. 查询数据 → queryStatistics
5
        2. 分析趋势 → analyzeTrend
6
        3. 检测异常 → detectAnomalies
7
        4. 生成报告 → generateReport
8

9
        工作流程:
10
        1. 理解用户问题
11
        2. 依次调用工具
12
        3. 综合分析结果
13
        4. 用专业语言回复
14
        """)
15
    TokenStream chat(@MemoryId String conversationId, @UserMessage String question);
16
}

显示更多显示更少

2. 定义工具类#

1
@Component
2
@RequiredArgsConstructor
3
public class DataQueryTools {
4
    private final DataRepository dataRepository;
5

6
    @Tool("查询统计数据")
7
    public String queryStatistics(
8
        @P("开始日期,格式 YYYY-MM-DD") String startDate,
9
        @P("结束日期,格式 YYYY-MM-DD") String endDate
10
    ) {
11
        List<DataRecord> records = dataRepository.findByDateBetween(startDate, endDate);
12
        return formatStatistics(records);
13
    }
14
}
15

16
@Component
17
public class AnalysisTools {
18
    @Tool("分析趋势")
19
    public String analyzeTrend(@P("趋势数据") String trendData) {
20
        // 分析逻辑...
21
    }
22

23
    @Tool("检测异常")
24
    public String detectAnomalies(@P("每日数据") String dailyData) {
25
        // 异常检测逻辑...
26
    }
27
}

显示更多显示更少

3. 配置 Agent Bean#

1
@Configuration
2
@RequiredArgsConstructor
3
public class LangChain4jConfig {
4
    private final DataQueryTools dataQueryTools;
5
    private final AnalysisTools analysisTools;
6

7
    @Bean
8
    public DataAnalystAgent dataAnalystAgent(StreamingChatLanguageModel model) {
9
        return AiServices.builder(DataAnalystAgent.class)
10
            .streamingChatLanguageModel(model)
11
            .chatMemoryProvider(memoryId ->
12
                MessageWindowChatMemory.withMaxMessages(20)
13
            )
14
            .tools(dataQueryTools, analysisTools)
15
            .build();
16
    }
17
}

显示更多显示更少

4. 实现流式接口#

1
@RestController
2
@RequestMapping("/api/v1/analyst")
3
@RequiredArgsConstructor
4
public class AnalystController {
5
    private final DataAnalystAgent agent;
6

7
    @PostMapping(value = "/chat", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
8
    public Flux<ServerSentEvent<String>> chat(
9
        @RequestParam String question,
10
        @RequestParam String conversationId
11
    ) {
12
        return Flux.create(sink -> {
13
            TokenStream stream = agent.chat(conversationId, question);
14

15
            stream
16
                .onNext(token -> sink.next(
17
                    ServerSentEvent.<String>builder()
18
                        .event("message")
19
                        .data(token)
20
                        .build()
21
                ))
22
                .onComplete(response -> {
23
                    sink.next(
24
                        ServerSentEvent.<String>builder()
25
                            .event("done")
26
                            .data("")
27
                            .build()
28
                    );
29
                    sink.complete();
30
                })
31
                .start();
32
        });
33
    }
34
}

显示更多显示更少

常见问题#

Q1: 如何切换到其他 LLM?#

LangChain4j 支持多种模型,只需更换依赖和配置:

使用 Azure OpenAI:

1
<dependency>
2
    <groupId>dev.langchain4j</groupId>
3
    <artifactId>langchain4j-azure-open-ai-spring-boot-starter</artifactId>
4
</dependency>

1
langchain4j:
2
  azure-open-ai:
3
    chat-model:
4
      endpoint: https://your-resource.openai.azure.com
5
      api-key: ${AZURE_OPENAI_API_KEY}
6
      deployment-name: gpt-4

使用 Google Gemini:

1
<dependency>
2
    <groupId>dev.langchain4j</groupId>
3
    <artifactId>langchain4j-vertex-ai-gemini-spring-boot-starter</artifactId>
4
</dependency>

Q2: 如何限制工具调用次数?#

在 System Prompt 中明确指示:

1
@SystemMessage("""
2
    你是助手。重要规则:
3
    - 每次回答最多调用 3 个工具
4
    - 优先使用已有数据,避免重复查询
5
    """)

Q3: 如何处理长上下文?#

使用 TokenWindowChatMemory 精确控制 Token 数:

1
.chatMemoryProvider(memoryId ->
2
    TokenWindowChatMemory.withMaxTokens(4000, new OpenAiTokenizer())
3
)

Q4: 如何实现多租户对话隔离?#

通过 @MemoryId 区分不同用户:

1
String memoryId = userId + ":" + conversationId;
2
agent.chat(memoryId, question);

总结#

通过本文,我们学习了如何使用 LangChain4j + Spring Boot 构建 AI Agent 应用,核心要点包括:

✅ AI Services: 通过接口 + 注解定义 AI 能力
✅ Function Calling: 让 AI 自动调用 Java 方法获取数据
✅ 对话记忆: 管理上下文,支持持久化
✅ 流式响应: 实时推送 AI 生成内容
✅ 多工具协作: AI 自动编排多个工具完成复杂任务

LangChain4j 的优势:

🎯 类型安全: 编译时检查,避免运行时错误
🚀 Spring 集成: 无缝集成 Spring Boot 生态
🔧 工具生态: 支持多种 LLM、向量数据库、嵌入模型
📚 文档完善: 官方文档 + 丰富示例

下一步建议:

📖 阅读 LangChain4j 官方文档
🔍 探索 RAG(检索增强生成)能力
🎨 集成向量数据库(如 Milvus、Qdrant)
🧪 尝试其他 LLM 模型(Claude, Gemini, DeepSeek)

参考资料#

Hibernate 懒加载陷阱:Lombok @Data 导致用户角色丢失的深度分析

Fri, 06 Feb 2026 00:00:00 GMT

问题起因#

在一个基于 Spring Boot 3.4.1 + Spring Security 的用户系统中,遇到了一个诡异的 Bug:用户登录成功,JWT Token 正常签发,但权限验证却全部失败。

症状表现#

1
// 日志输出
2
=== DEBUG: User loaded ===
3
Username: admin
4
Roles count: 0           // ❌ 期望值应该是 1
5
========================

更奇怪的是,第一条 SQL 查询明明成功 JOIN 了 sys_role 表,却在业务逻辑中丢失了角色数据。

问题排查过程#

第一步:检查 SQL 日志#

启用 Hibernate SQL 日志后,发现了异常的查询序列:

1
-- ✅ 第一条查询 (正确)
2
SELECT DISTINCT u.*, r.*
3
FROM sys_user u
4
LEFT JOIN sys_user_role ur ON u.id = ur.user_id
5
LEFT JOIN sys_role r ON r.id = ur.role_id
6
WHERE u.username = ?
7

8
-- ⚠️ 后续触发的额外查询
9
SELECT p.* FROM sys_role_permission rp
10
JOIN sys_permission p ON p.id = rp.permission_id
11
WHERE rp.role_id = ?
12

13
SELECT u.* FROM sys_user_role ur
14
JOIN sys_user u ON u.id = ur.user_id
15
WHERE ur.role_id = ?
16

17
SELECT r.* FROM sys_user_role ur
18
JOIN sys_role r ON r.id = ur.role_id
19
WHERE ur.user_id = ?

显示更多显示更少

关键发现: 后续的 3-4 条 SQL 查询是意外触发的懒加载!

第二步:定位触发点#

通过调试,发现触发点在调试日志中:

1
@Override
2
@Transactional
3
public UserDetails loadUserByUsername(String username) {
4
    User user = userRepository.findByUsernameWithRoles(username)
5
        .orElseThrow(() -> new UsernameNotFoundException("..."));
6

7
    // 🔴 触发点:这行日志
8
    user.getRoles().forEach(role -> {
9
        System.out.println("  Role: " + role.getCode() + " (" + role.getName() + ")");
10
    });
11

12
    return UserDetailsImpl.build(user);
13
}

问题: 为什么访问 role.getCode() 会触发额外的 SQL 查询?

第三步:找到罪魁祸首#

检查 Role 实体类,发现了问题所在:

1
@Data  // 🔴 问题根源!
2
@Entity
3
@Table(name = "sys_role")
4
public class Role {
5
    // ...
6

7
    @ManyToMany(fetch = FetchType.LAZY)
8
    private Set<Permission> permissions = new HashSet<>();
9

10
    @ManyToMany(mappedBy = "roles", fetch = FetchType.LAZY)
11
    private Set<User> users = new HashSet<>();
12
}

关键洞察:

Lombok @Data 注解自动生成的 toString() 方法会访问所有字段,包括懒加载的 permissions 和 users:

1
// Lombok 自动生成的代码
2
@Override
3
public String toString() {
4
    return "Role{" +
5
        "id=" + id +
6
        ", name=" + name +
7
        ", permissions=" + permissions +  // 🔴 触发懒加载!
8
        ", users=" + users +               // 🔴 触发循环引用!
9
        "}";
10
}

当调试日志中隐式调用 role.toString() 时,就会触发这些懒加载字段的查询,导致 Hibernate Session 状态混乱,最终角色集合丢失!

问题本质#

这是一个典型的 Lombok 便利性 vs JPA 懒加载的冲突:

触发链路#

1
1. 调用 userRepository.findByUsernameWithRoles()
2
   ↓ ✅ SQL 正确查询,roles 集合已加载
3

4
2. 调试日志访问 role 对象
5
   ↓ 🔴 隐式调用 role.toString()
6

7
3. Lombok @Data 生成的 toString() 访问 permissions
8
   ↓ 🔴 触发 Hibernate 懒加载查询
9

10
4. toString() 访问 users (双向引用)
11
   ↓ 🔴 触发循环查询 User → Role → User...
12

13
5. Hibernate Session 状态混乱
14
   ↓ ❌ roles 集合被清空
15

16
6. UserDetailsImpl.build(user) 获取空角色列表
17
   ↓ ❌ 权限验证失败

显示更多显示更少

性能影响#

指标	修复前	修复后
SQL 查询次数	5-6 条	1 条
响应时间	50-100ms	10-20ms
角色数据	❌ 丢失	✅ 正常

解决方案#

核心策略#

移除 Lombok @Data,手动实现 toString/equals/hashCode,仅访问基础字段

修复代码#

1. Role 实体类#

1
@Getter  // ✅ 替换 @Data
2
@Setter
3
@Entity
4
@Table(name = "sys_role")
5
public class Role {
6
    @Id
7
    @GeneratedValue(strategy = GenerationType.IDENTITY)
8
    private Long id;
9

10
    @Column(nullable = false)
11
    private String name;
12

13
    @Column(unique = true, nullable = false, length = 50)
14
    private String code;
15

16
    @ManyToMany(fetch = FetchType.LAZY)
17
    private Set<Permission> permissions = new HashSet<>();
18

19
    @ManyToMany(mappedBy = "roles", fetch = FetchType.LAZY)
20
    private Set<User> users = new HashSet<>();
21

22
    // ✅ 自定义 toString(),仅输出基础字段
23
    @Override
24
    public String toString() {
25
        return "Role{id=" + id + ", code=" + code + ", name=" + name + "}";
26
    }
27

28
    // ✅ equals/hashCode 仅使用 ID
29
    @Override
30
    public boolean equals(Object o) {
31
        if (this == o) return true;
32
        if (!(o instanceof Role)) return false;
33
        Role role = (Role) o;
34
        return id != null && id.equals(role.id);
35
    }
36

37
    @Override
38
    public int hashCode() {
39
        return getClass().hashCode();
40
    }
41
}

显示更多显示更少

2. User 实体类#

1
@Getter
2
@Setter
3
@Entity
4
@Table(name = "sys_user")
5
public class User {
6
    // ... 字段定义 ...
7

8
    @ManyToMany(fetch = FetchType.EAGER)
9
    @JoinTable(...)
10
    private Set<Role> roles = new HashSet<>();
11

12
    // ✅ 避免循环引用
13
    @Override
14
    public String toString() {
15
        return "User{id=" + id + ", username=" + username + "}";
16
    }
17

18
    @Override
19
    public boolean equals(Object o) {
20
        if (this == o) return true;
21
        if (!(o instanceof User)) return false;
22
        User user = (User) o;
23
        return id != null && id.equals(user.id);
24
    }
25

26
    @Override
27
    public int hashCode() {
28
        return getClass().hashCode();
29
    }
30
}

显示更多显示更少

3. Permission 实体类(预防性修复)#

1
@Getter
2
@Setter
3
@Entity
4
@Table(name = "sys_permission")
5
public class Permission {
6
    // ... 字段定义 ...
7

8
    @Override
9
    public String toString() {
10
        return "Permission{id=" + id + ", code=" + code + "}";
11
    }
12

13
    @Override
14
    public boolean equals(Object o) {
15
        if (this == o) return true;
16
        if (!(o instanceof Permission)) return false;
17
        Permission p = (Permission) o;
18
        return id != null && id.equals(p.id);
19
    }
20

21
    @Override
22
    public int hashCode() {
23
        return getClass().hashCode();
24
    }
25
}

显示更多显示更少

修复效果#

日志对比#

修复前:

1
=== DEBUG: User loaded ===
2
Username: admin
3
Roles count: 0           ❌
4
========================
5

6
SQL Logs: 5-6 条查询 (包括循环查询)

修复后:

1
仅 1 条 SQL 查询,无额外懒加载
2
Roles count: 1           ✅
3
权限验证通过             ✅

性能提升#

🚀 SQL 查询减少 83% (6 → 1)
🚀 响应时间降低 70% (50-100ms → 10-20ms)
🚀 避免 N+1 查询问题
🚀 减少数据库连接占用

经验总结#

Lombok 使用规范#

❌ 错误用法#

1
// JPA 实体类禁止使用 @Data
2
@Data
3
@Entity
4
public class MyEntity {
5
    @ManyToMany
6
    private Set<OtherEntity> relations;  // toString() 会触发懒加载
7
}

✅ 正确用法#

方案 1: 手动实现 toString

1
@Getter
2
@Setter
3
@Entity
4
public class MyEntity {
5
    @ManyToMany
6
    private Set<OtherEntity> relations;
7

8
    @Override
9
    public String toString() {
10
        return "MyEntity{id=" + id + "}";  // 仅输出基础字段
11
    }
12
}

方案 2: 使用 @ToString.Exclude

1
@Data
2
@Entity
3
public class MyEntity {
4
    @ToString.Exclude  // 排除懒加载字段
5
    @EqualsAndHashCode.Exclude
6
    @ManyToMany
7
    private Set<OtherEntity> relations;
8
}

JPA 实体类最佳实践#

toString: 仅输出基础字段,不访问关联字段
equals/hashCode: 仅使用 ID 比较
双向关联: 必须在一侧排除 toString/equals
懒加载访问: 使用 JOIN FETCH 一次性加载,避免 N+1 查询

代码审查检查清单#

JPA 实体类是否使用了 @Data?
双向关联是否配置了 @ToString.Exclude?
equals/hashCode 是否仅使用 ID?
是否存在调试日志输出整个实体对象?

预防措施#

静态代码分析规则#

1
<!-- Maven PMD/Checkstyle 规则 -->
2
<rule>
3
  <id>NO_DATA_ON_JPA_ENTITY</id>
4
  <message>JPA 实体类禁止使用 @Data 注解</message>
5
  <pattern>@Data.*@Entity</pattern>
6
</rule>

单元测试#

1
@Test
2
void testToStringDoesNotTriggerLazyLoading() {
3
    User user = userRepository.findByUsernameWithRoles("admin").orElseThrow();
4

5
    // 验证 toString 不触发额外查询
6
    User spy = Mockito.spy(user);
7
    String toString = spy.toString();
8

9
    // 验证没有访问懒加载字段
10
    Mockito.verify(spy, Mockito.never()).getRoles();
11
}

参考资料#

总结#

这个 Bug 揭示了一个重要的开发原则:便利性工具(如 Lombok)必须与框架特性(如 JPA 懒加载)配合使用。

核心教训:

在 JPA 实体类上禁用 @Data,手动控制 toString/equals/hashCode
双向关联必须排除循环引用字段
调试日志不要输出整个实体对象
使用静态分析工具强制检查

背包问题完全指南

Fri, 06 Feb 2026 00:00:00 GMT

背包问题完全指南#

背包问题是动态规划中的经典问题，也是面试和竞赛中的高频考点。本文将系统性地介绍各类背包问题的原理、解法和例题。

背包问题分类体系#

graph TB A[背包问题] --> B[01背包] A --> C[完全背包] A --> D[多重背包] A --> E[分组背包] A --> F[混合背包] A --> G[二维费用背包] B --> B1[每件物品最多选一次] C --> C1[每件物品无限次使用] D --> D1[每件物品有数量限制] E --> E1[每组最多选一件] F --> F1[混合多种类型] G --> G1[两个维度限制] style B fill:#e1f5ff style C fill:#fff4e1 style D fill:#ffe1f5 style E fill:#e1ffe1 style F fill:#f5e1ff style G fill:#ffe1e1

一、01 背包问题#

问题描述#

有 N 件物品和一个容量为 V 的背包。第 i 件物品的体积是 w[i]，价值是 v[i]。每件物品最多只能选一次，求解将哪些物品装入背包可使价值总和最大。

决策树图解#

graph TD A[物品1: 选或不选] --> B[选: 剩余容量V-w1] A --> C[不选: 剩余容量V] B --> D[物品2: 选或不选] C --> E[物品2: 选或不选] D --> F[...] E --> G[...] style A fill:#e1f5ff style B fill:#d4edda style C fill:#f8d7da

状态定义#

dp[i][j] 表示前 i 件物品放入容量为 j 的背包中的最大价值。

状态转移方程#

1
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i])

dp[i-1][j]：不选第 i 件物品
dp[i-1][j-w[i]] + v[i]：选第 i 件物品（前提是 j >= w[i]）

空间优化（一维数组）#

由于 dp[i] 只依赖于 dp[i-1]，可以用一维数组优化：

1
for (int i = 1; i <= n; i++) {
2
    for (int j = V; j >= w[i]; j--) {  // 逆序遍历
3
        dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
4
    }
5
}

关键点：逆序遍历是为了保证每个物品只被使用一次。

01 背包遍历方向图解#

graph LR A[容量 V] -->|逆序| B[V-1] B --> C[V-2] C --> D[...] D --> E[w_i] style A fill:#e1f5ff style E fill:#d4edda F[原因: 防止物品被重复使用] -.-> A

例题：AcWing 2. 01背包问题 #

题目描述：有 N 件物品和一个容量是 V 的背包。每件物品只能用一次。第 i 件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

代码实现：

1
import java.util.Scanner;
2

3
public class Knapsack01 {
4
    static final int MAXN = 1005;
5
    static int n, V;
6
    static int[] w = new int[MAXN];
7
    static int[] v = new int[MAXN];
8
    static int[] dp = new int[MAXN];
9

10
    public static void main(String[] args) {
11
        Scanner sc = new Scanner(System.in);
12
        n = sc.nextInt();
13
        V = sc.nextInt();
14

15
        for (int i = 1; i <= n; i++) {
16
            w[i] = sc.nextInt();
17
            v[i] = sc.nextInt();
18
        }
19

20
        for (int i = 1; i <= n; i++) {
21
            for (int j = V; j >= w[i]; j--) {
22
                dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
23
            }
24
        }
25

26
        System.out.println(dp[V]);
27
        sc.close();
28
    }
29
}

显示更多显示更少

二、完全背包问题#

问题描述#

有 N 种物品和一个容量为 V 的背包。第 i 种物品的体积是 w[i]，价值是 v[i]。每种物品有无限件可用，求解将哪些物品装入背包可使价值总和最大。

状态转移方程#

1
dp[i][j] = max(dp[i-1][j], dp[i][j-w[i]] + v[i])

注意与 01 背包的区别：这里是 dp[i][j-w[i]] 而不是 dp[i-1][j-w[i]]，因为物品可以重复选择。

空间优化（一维数组）#

1
for (int i = 1; i <= n; i++) {
2
    for (int j = w[i]; j <= V; j++) {  // 正序遍历
3
        dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
4
    }
5
}

关键点：正序遍历，允许物品被重复使用。

完全背包遍历方向图解#

graph LR A[容量 w_i] -->|正序| B[w_i+1] B --> C[w_i+2] C --> D[...] D --> E[V] style A fill:#fff4e1 style E fill:#d4edda F[原因: 允许物品被重复选择] -.-> A

例题：AcWing 3. 完全背包问题 #

题目描述：有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。第 i 种物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

代码实现：

1
import java.util.Scanner;
2

3
public class CompleteKnapsack {
4
    static final int MAXN = 1005;
5
    static int n, V;
6
    static int[] w = new int[MAXN];
7
    static int[] v = new int[MAXN];
8
    static int[] dp = new int[MAXN];
9

10
    public static void main(String[] args) {
11
        Scanner sc = new Scanner(System.in);
12
        n = sc.nextInt();
13
        V = sc.nextInt();
14

15
        for (int i = 1; i <= n; i++) {
16
            w[i] = sc.nextInt();
17
            v[i] = sc.nextInt();
18
        }
19

20
        for (int i = 1; i <= n; i++) {
21
            for (int j = w[i]; j <= V; j++) {
22
                dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
23
            }
24
        }
25

26
        System.out.println(dp[V]);
27
        sc.close();
28
    }
29
}

显示更多显示更少

三、多重背包问题#

问题描述#

有 N 种物品和一个容量为 V 的背包。第 i 种物品最多有 s[i] 件，每件体积是 w[i]，价值是 v[i]。求解将哪些物品装入背包可使价值总和最大。

朴素解法（三重循环）#

1
for (int i = 1; i <= n; i++) {
2
    for (int j = V; j >= w[i]; j--) {
3
        for (int k = 1; k <= s[i] && k * w[i] <= j; k++) {
4
            dp[j] = Math.max(dp[j], dp[j - k * w[i]] + k * v[i]);
5
        }
6
    }
7
}

时间复杂度：O(V * Σs[i])

二进制优化#

将每种物品的 s[i] 件拆分成若干组，每组的数量为 2 的幂次（1, 2, 4, 8, …），然后转化为 01 背包问题。

拆分原理：任何正整数都可以用若干个 2 的幂次表示。例如 s[i] = 10，可以拆分为 1, 2, 4, 3（1+2+4+3=10）。

二进制拆分图解#

graph LR A[10件物品] --> B[拆分为] B --> C[1件] B --> D[2件] B --> E[4件] B --> F[3件] C --> G[可组合出 0-10 的任意数量] D --> G E --> G F --> G style A fill:#ffe1f5 style G fill:#d4edda

代码实现：

1
import java.util.Scanner;
2

3
public class MultipleKnapsack {
4
    static final int MAXN = 25005;
5
    static int n, V;
6
    static int[] w = new int[MAXN];
7
    static int[] v = new int[MAXN];
8
    static int[] dp = new int[MAXN];
9

10
    public static void main(String[] args) {
11
        Scanner sc = new Scanner(System.in);
12
        n = sc.nextInt();
13
        V = sc.nextInt();
14

15
        int cnt = 0;  // 拆分后的物品总数
16
        for (int i = 1; i <= n; i++) {
17
            int a = sc.nextInt();  // 体积
18
            int b = sc.nextInt();  // 价值
19
            int s = sc.nextInt();  // 数量
20

21
            int k = 1;
22
            while (k <= s) {
23
                cnt++;
24
                w[cnt] = k * a;
25
                v[cnt] = k * b;
26
                s -= k;
27
                k *= 2;
28
            }
29
            if (s > 0) {
30
                cnt++;
31
                w[cnt] = s * a;
32
                v[cnt] = s * b;
33
            }
34
        }
35

36
        // 01 背包
37
        for (int i = 1; i <= cnt; i++) {
38
            for (int j = V; j >= w[i]; j--) {
39
                dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
40
            }
41
        }
42

43
        System.out.println(dp[V]);
44
        sc.close();
45
    }
46
}

显示更多显示更少

例题：AcWing 4. 多重背包问题 I #

使用二进制优化解法，时间复杂度降低到 O(V * Σlog(s[i]))。

四、分组背包问题#

问题描述#

有 N 组物品和一个容量为 V 的背包。第 i 组物品有 s[i] 件，同一组内的物品最多只能选一件。每件物品有体积和价值。求解将哪些物品装入背包可使价值总和最大。

分组背包图解#

graph TD A[第1组] --> B[物品1-1] A --> C[物品1-2] A --> D[物品1-3] E[第2组] --> F[物品2-1] E --> G[物品2-2] H[最多选一件] -.-> A I[最多选一件] -.-> E style A fill:#e1ffe1 style E fill:#e1ffe1 style B fill:#fff4e1 style C fill:#fff4e1 style D fill:#fff4e1 style F fill:#ffe1f5 style G fill:#ffe1f5

状态转移方程#

1
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i][k]] + v[i][k])  // k 枚举第 i 组的所有物品

空间优化（一维数组）#

1
for (int i = 1; i <= n; i++) {  // 枚举组
2
    for (int j = V; j >= 0; j--) {  // 逆序枚举体积
3
        for (int k = 1; k <= s[i]; k++) {  // 枚举组内物品
4
            if (j >= w[i][k]) {
5
                dp[j] = Math.max(dp[j], dp[j - w[i][k]] + v[i][k]);
6
            }
7
        }
8
    }
9
}

例题：AcWing 9. 分组背包问题 #

代码实现：

1
import java.util.Scanner;
2

3
public class GroupKnapsack {
4
    static final int MAXN = 105;
5
    static int n, V;
6
    static int[] s = new int[MAXN];  // 每组物品数量
7
    static int[][] w = new int[MAXN][MAXN];  // 每组物品的体积
8
    static int[][] v = new int[MAXN][MAXN];  // 每组物品的价值
9
    static int[] dp = new int[MAXN];
10

11
    public static void main(String[] args) {
12
        Scanner sc = new Scanner(System.in);
13
        n = sc.nextInt();
14
        V = sc.nextInt();
15

16
        for (int i = 1; i <= n; i++) {
17
            s[i] = sc.nextInt();
18
            for (int j = 1; j <= s[i]; j++) {
19
                w[i][j] = sc.nextInt();
20
                v[i][j] = sc.nextInt();
21
            }
22
        }
23

24
        for (int i = 1; i <= n; i++) {
25
            for (int j = V; j >= 0; j--) {
26
                for (int k = 1; k <= s[i]; k++) {
27
                    if (j >= w[i][k]) {
28
                        dp[j] = Math.max(dp[j], dp[j - w[i][k]] + v[i][k]);
29
                    }
30
                }
31
            }
32
        }
33

34
        System.out.println(dp[V]);
35
        sc.close();
36
    }
37
}

显示更多显示更少

五、混合背包问题#

问题描述#

有的物品只能用一次（01背包），有的物品可以无限用（完全背包），有的物品有数量限制（多重背包）。

解法#

根据物品类型分别处理：

1
for (int i = 1; i <= n; i++) {
2
    if (物品类型 == 01背包) {
3
        for (int j = V; j >= w[i]; j--) {
4
            dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
5
        }
6
    } else if (物品类型 == 完全背包) {
7
        for (int j = w[i]; j <= V; j++) {
8
            dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
9
        }
10
    } else if (物品类型 == 多重背包) {
11
        // 使用二进制优化
12
    }
13
}

六、二维费用背包#

问题描述#

物品不仅有重量限制，还有体积限制。第 i 件物品的重量是 w[i]，体积是 v[i]，价值是 val[i]。背包的最大重量是 W，最大体积是 V。

状态定义#

dp[i][j][k] 表示前 i 件物品，重量不超过 j，体积不超过 k 的最大价值。

空间优化（二维数组）#

1
for (int i = 1; i <= n; i++) {
2
    for (int j = W; j >= w[i]; j--) {
3
        for (int k = V; k >= v[i]; k--) {
4
            dp[j][k] = Math.max(dp[j][k], dp[j - w[i]][k - v[i]] + val[i]);
5
        }
6
    }
7
}

例题：AcWing 8. 二维费用的背包问题 #

代码实现：

1
import java.util.Scanner;
2

3
public class TwoDimensionalKnapsack {
4
    static final int MAXN = 105;
5
    static int n, W, V;
6
    static int[] w = new int[MAXN];
7
    static int[] v = new int[MAXN];
8
    static int[] val = new int[MAXN];
9
    static int[][] dp = new int[MAXN][MAXN];
10

11
    public static void main(String[] args) {
12
        Scanner sc = new Scanner(System.in);
13
        n = sc.nextInt();
14
        W = sc.nextInt();
15
        V = sc.nextInt();
16

17
        for (int i = 1; i <= n; i++) {
18
            w[i] = sc.nextInt();
19
            v[i] = sc.nextInt();
20
            val[i] = sc.nextInt();
21
        }
22

23
        for (int i = 1; i <= n; i++) {
24
            for (int j = W; j >= w[i]; j--) {
25
                for (int k = V; k >= v[i]; k--) {
26
                    dp[j][k] = Math.max(dp[j][k], dp[j - w[i]][k - v[i]] + val[i]);
27
                }
28
            }
29
        }
30

31
        System.out.println(dp[W][V]);
32
        sc.close();
33
    }
34
}

显示更多显示更少

七、背包问题变种#

1. 求方案数#

在普通背包的基础上，统计有多少种方案可以达到最大价值。

状态定义：

dp[j]：容量为 j 的最大价值
cnt[j]：达到最大价值的方案数

转移方程：

1
if (dp[j - w[i]] + v[i] > dp[j]) {
2
    dp[j] = dp[j - w[i]] + v[i];
3
    cnt[j] = cnt[j - w[i]];
4
} else if (dp[j - w[i]] + v[i] == dp[j]) {
5
    cnt[j] += cnt[j - w[i]];
6
}

2. 求具体方案#

使用二维数组 dp[i][j] 记录状态，然后倒推出选了哪些物品。

1
// 倒推方案
2
List<Integer> path = new ArrayList<>();
3
int j = V;
4
for (int i = n; i >= 1; i--) {
5
    if (dp[i][j] == dp[i-1][j - w[i]] + v[i]) {
6
        path.add(i);
7
        j -= w[i];
8
    }
9
}

3. 恰好装满背包#

初始化时，dp[0] = 0，其他 dp[j] = -∞（表示不可达状态）。

1
Arrays.fill(dp, Integer.MIN_VALUE / 2);
2
dp[0] = 0;

4. 求第 k 优解#

维护每个状态的前 k 个最优值。

八、经典例题汇总#

题目	类型	链接
AcWing 2. 01背包问题	01背包	链接
AcWing 3. 完全背包问题	完全背包	链接
AcWing 4. 多重背包问题 I	多重背包	链接
AcWing 5. 多重背包问题 II	多重背包（二进制优化）	链接
AcWing 9. 分组背包问题	分组背包	链接
AcWing 8. 二维费用的背包问题	二维背包	链接
LeetCode 416. 分割等和子集	01背包变种	链接
LeetCode 322. 零钱兑换	完全背包变种	链接
LeetCode 518. 零钱兑换 II	完全背包（方案数）	链接

九、总结对比#

核心差异对比表#

背包类型	特点	内层循环方向	时间复杂度
01 背包	每件物品最多选一次	逆序（V → 0）	O(NV)
完全背包	每件物品无限次	正序（0 → V）	O(NV)
多重背包	每件物品最多 s 次	逆序 + 二进制优化	O(V·Σlog(s))
分组背包	每组最多选一件	逆序	O(N·V·S)
混合背包	混合多种类型	根据类型决定	-
二维费用	两个维度限制	双重逆序	O(N·W·V)

决策流程图#

flowchart TD Start[开始] --> Q1{每件物品可用多少次?} Q1 -->|最多1次| A[01背包] Q1 -->|无限次| B[完全背包] Q1 -->|有限制s次| C[多重背包] Q1 -->|组内互斥| D{是否分组?} D -->|是| E[分组背包] Q1 -->|混合类型| F[混合背包] Q1 -->|多维限制| G{几个维度?} G -->|2个| H[二维费用背包] A --> End[选择对应模板] B --> End C --> End E --> End F --> End H --> End style A fill:#e1f5ff style B fill:#fff4e1 style C fill:#ffe1f5 style E fill:#e1ffe1 style F fill:#f5e1ff style H fill:#ffe1e1

十、刷题建议#

基础阶段：先刷 AcWing 的背包九讲，掌握基本模板
进阶阶段：LeetCode 上的背包变种题，理解状态转移的本质
综合应用：Codeforces、AtCoder 等平台的动态规划题

背包问题的核心是理解状态定义和状态转移方程，熟练掌握后可以轻松应对各种变种！

参考资料：

如果觉得本文有帮助，欢迎分享给更多的朋友！

Windows被占用文件夹删除

Thu, 05 Feb 2026 00:00:00 GMT

资源监视器

Win+R → 输入 resmon → 回车
选“CPU”页 → 右侧“关联的句柄”搜索框输入 文件名
找到进程名 → 右键结束进程或先关闭对应应用

SuperJeason

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 工具类（重点补充）#

1.8 全数据结构 CRUD 速查#

1.8.1 Array 的 CRUD#

1.8.2 ArrayList 的 CRUD#

1.8.3 LinkedList 的 CRUD#

1.8.4 HashMap 的 CRUD#

1.8.5 HashSet 的 CRUD#

1.8.6 TreeMap 的 CRUD#

1.8.7 TreeSet 的 CRUD#

1.8.8 Queue 的 CRUD（FIFO）#

1.8.9 Deque 的 CRUD（双端）#

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

1.8.11 Arrays 在 CRUD 中的辅助角色#

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

2.1 核心方法和行为#

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

2.3 poll 和 remove 的区别#

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

3.1 常用方法#

3.2 示例：双端任务池#

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

4.1 核心特性#

4.2 示例一：默认最小堆#

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

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

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

5.1 Map 常用快捷接口#

5.2 List 常用快捷接口#

5.3 Stream 一行管道示例#

5.4 Arrays 常用快捷接口#

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

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

6.1 场景说明#

6.2 代码示例#

6.3 适用场景#

7. 常见坑#

7.1 队列行为相关#

7.2 集合与并发相关#

8. 总结#

8.1 三条速记#

LangChain4j Agent 开发指南:用 Java 构建智能应用

前言#

什么是 LangChain4j?#

LangChain4j 架构图#

快速开始#

1. 添加依赖#

2. 配置 LLM 连接#

核心概念 Services#

什么是 AI Services?#

定义 AI Agent 接口#

注解说明#

Function Calling:让 AI 调用 Java 方法#

什么是 Function Calling?#

Function Calling 工作流程#

定义工具类#

注解说明#

配置 AI Agent Bean#

配置说明#

对话记忆管理#

为什么需要对话记忆?#

内置记忆策略#

对话记忆工作原理#

自定义持久化记忆#

流式响应处理#

为什么需要流式响应?#

实现流式接口#

流式事件说明#

高级特性:多工具协作#

场景:生成数据分析报告#

AI 自动编排工作流程#

定义多个工具类#

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` 工具类（重点补充）#

1.8.1 `Array` 的 CRUD#

1.8.2 `ArrayList` 的 CRUD#

1.8.3 `LinkedList` 的 CRUD#

1.8.4 `HashMap` 的 CRUD#

1.8.5 `HashSet` 的 CRUD#

1.8.6 `TreeMap` 的 CRUD#

1.8.7 `TreeSet` 的 CRUD#

1.8.8 `Queue` 的 CRUD（FIFO）#

1.8.9 `Deque` 的 CRUD（双端）#

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

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

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

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

5.1 `Map` 常用快捷接口#

5.2 `List` 常用快捷接口#

5.3 `Stream` 一行管道示例#

5.4 `Arrays` 常用快捷接口#

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

例题：AcWing 2. 01背包问题 #

例题：AcWing 3. 完全背包问题 #