```java import java.util.*; public class IntervalConnector { public static void main(String[] args) { // 测试用例一 int[][] nums1 = {{1, 2}, {3, 5}, {7, 10}, {15, 20}, {30, 100}}; List<Integer> combination1 = new ArrayList<>(Arrays.asList(5, 4, 3, 2, 1)); main(nums1, combination1); // 测试用例二 int[][] nums2 = {{1, 10}, {15, 20}, {18, 30}, {33, 40}}; List<Integer> combination2 = new ArrayList<>(Arrays.asList(5, 4, 3, 2)); main(nums2, combination2); } public static void main(int[][] nums, List<Integer> comb) { // 区间排序：先按起点升序，起点相同按终点升序 Arrays.sort(nums, (a, b) -> { if (a[0] != b[0]) { return Integer.compare(a[0], b[0]); } return Integer.compare(a[1], b[1]); }); List<int[]> stack = new ArrayList<>(); // 合并相邻、重叠的区间 for (int[] num : nums) { if (!stack.isEmpty()) { int[] m = stack.get(stack.size() - 1); if (m[0] < num[0] && num[0] <= m[1]) { // 当前区间与栈顶区间重叠 stack.remove(stack.size() - 1); stack.add(new int[]{m[0], num[1]}); } else if (m[0] == num[0]) { // 起点相同，取终点较大的区间 stack.remove(stack.size() - 1); stack.add(new int[]{num[0], Math.max(m[1], num[1])}); } else if (m[1] == num[0]) { // 相邻区间，直接合并 stack.remove(stack.size() - 1); stack.add(new int[]{m[0], num[1]}); } else if (m[1] > num[1]) { // 当前区间完全被栈顶区间包含，跳过 continue; } else { // 无重叠且不相邻，直接加入 stack.add(num); } } else { stack.add(num); } } System.out.println("合并后的区间: " + Arrays.deepToString(stack.toArray())); // 使用连接器连接分离的区间 List<int[]> newStack = new ArrayList<>(); for (int[] s : stack) { if (!newStack.isEmpty()) { int[] p = newStack.get(newStack.size() - 1); int div = s[0] - p[1]; // 计算区间间距 if (comb.contains(div)) { // 找到合适的连接器，合并区间 newStack.remove(newStack.size() - 1); newStack.add(new int[]{p[0], s[1]}); comb.remove((Integer) div); // 使用连接器 } else { newStack.add(s); } } else { newStack.add(s); } } System.out.println("连接后的区间: " + Arrays.deepToString(newStack.toArray())); System.out.println("最终区间数量: " + newStack.size()); } } ``` ## 关键转换要点说明 ### 1. 数据结构转换 - **列表类型**：Python的`List`转换为Java的`List<Integer>`和`List<int[]>` - **二维数组**：Python的嵌套列表转换为Java的二维数组`int[][]` - **排序实现**：使用`Arrays.sort()`配合Lambda表达式替代Python的`sort(key=)` ### 2. 语法差异处理 - **列表操作**：Python的`list.pop()`转换为Java的`list.remove(list.size()-1)` - **成员检查**：Python的`in`操作转换为Java的`contains()`方法 - **打印输出**：使用`Arrays.deepToString()`处理嵌套数组的打印 ### 3. 算法逻辑保持 - **区间合并策略**：完全保持原有的四种合并条件判断逻辑 - **连接器使用**：维持相同的间距计算和连接器匹配机制 - **处理顺序**：保持先合并重叠区间，再使用连接器的两阶段处理 ### 4. 类型安全增强 ```java // 明确的类型声明 List<int[]> stack = new ArrayList<>(); List<Integer> combination = new ArrayList<>(); // 安全的类型转换 comb.remove((Integer) div); // 避免按索引删除的歧义 ``` ### 5. 测试用例验证 代码包含两个完整的测试用例，分别对应博客中提到的两个场景，确保转换后的Java代码能够正确输出预期结果[ref_1]。 该Java实现完整复现了Python版本的算法逻辑，在保持核心处理流程不变的同时，适应了Java语言的类型系统和集合框架特性。