一、嵌套集合的构建与基础遍历

1.1 嵌套集合的典型结构

Java集合框架支持多层嵌套，常见形式包括：

• List<List<T>>：二维列表结构
• Map<K, Map<K,V>>：层级映射结构
• 混合嵌套：Map<String, List<Map<Integer, String>>>

典型应用场景：

• 矩阵数据处理（如电子表格）
• 分层配置系统（如多级菜单）
• 复杂JSON/XML解析

// 二维列表示例
List<List<String>> matrix = new ArrayList<>();
matrix.add(Arrays.asList("A1", "B1"));
matrix.add(Arrays.asList("A2", "B2"));
// 嵌套Map示例
Map<String, Map<Integer, String>> userRoles = new HashMap<>();
Map<Integer, String> adminRoles = new HashMap<>();
adminRoles.put(1, "System Admin");
userRoles.put("admin", adminRoles);

1.2 嵌套集合的遍历方法

增强for循环遍历

for (List<String> row : matrix) {
    for (String cell : row) {
        System.out.print(cell + " ");
    }
    System.out.println();
}

Iterator迭代器遍历

Iterator<List<String>> rowIterator = matrix.iterator();
while (rowIterator.hasNext()) {
    List<String> row = rowIterator.next();
    Iterator<String> cellIterator = row.iterator();
    while (cellIterator.hasNext()) {
        System.out.print(cellIterator.next() + " ");
    }
    System.out.println();
}

Java 8 Stream API处理

matrix.stream()
      .flatMap(List::stream)
      .forEach(System.out::println);

二、嵌套keySet的深度遍历

2.1 多层keySet的迭代模式

处理Map<String, Map<String, Integer>>结构时，需要双重keySet遍历：

Map<String, Map<String, Integer>> departmentSalaries = new HashMap<>();
// 初始化数据...
// 传统双重遍历
for (String dept : departmentSalaries.keySet()) {
    System.out.println("Department: " + dept);
    Map<String, Integer> employees = departmentSalaries.get(dept);
    for (String emp : employees.keySet()) {
        System.out.println("  Employee: " + emp + 
                          ", Salary: " + employees.get(emp));
    }
}

2.2 优化遍历方案

使用entrySet替代keySet

for (Map.Entry<String, Map<String, Integer>> deptEntry : 
     departmentSalaries.entrySet()) {
    System.out.println("Department: " + deptEntry.getKey());
    Map<String, Integer> employees = deptEntry.getValue();
    for (Map.Entry<String, Integer> empEntry : employees.entrySet()) {
        System.out.println("  Employee: " + empEntry.getKey() + 
                          ", Salary: " + empEntry.getValue());
    }
}

Java 8+的forEach方法

departmentSalaries.forEach((dept, employees) -> {
    System.out.println("Department: " + dept);
    employees.forEach((emp, salary) -> 
        System.out.println("  Employee: " + emp + ", Salary: " + salary));
});

三、嵌套entrySet的深度处理

3.1 复杂嵌套结构的解析

处理Map<String, List<Map<Integer, String>>>>结构示例：

Map<String, List<Map<Integer, String>>> studentRecords = new HashMap<>();
// 初始化数据...
// 传统三层嵌套遍历
for (Map.Entry<String, List<Map<Integer, String>>> classEntry : 
     studentRecords.entrySet()) {
    System.out.println("Class: " + classEntry.getKey());
    List<Map<Integer, String>> students = classEntry.getValue();
    for (Map<Integer, String> student : students) {
        for (Map.Entry<Integer, String> record : student.entrySet()) {
            System.out.println("  Student ID: " + record.getKey() + 
                              ", Name: " + record.getValue());
        }
    }
}

3.2 现代Java的优化方案

使用Stream API进行扁平化处理

studentRecords.entrySet().stream()
    .peek(classEntry -> System.out.println("Class: " + classEntry.getKey()))
    .flatMap(classEntry -> classEntry.getValue().stream())
    .flatMap(student -> student.entrySet().stream())
    .forEach(record -> System.out.println(
        "  Student ID: " + record.getKey() + 
        ", Name: " + record.getValue()));

自定义收集器处理

Map<String, Map<Integer, String>> flattened = studentRecords.entrySet().stream()
    .flatMap(classEntry -> classEntry.getValue().stream()
        .flatMap(student -> student.entrySet().stream()
            .map(record -> new AbstractMap.SimpleEntry<>(
                classEntry.getKey() + "-" + record.getKey(),
                record.getValue()))))
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        (v1, v2) -> v1, // 处理键冲突
        HashMap::new));

四、性能优化与最佳实践

4.1 遍历性能对比

遍历方式	适用场景	性能特点
双重keySet	仅需键的简单场景	中等，需两次查找
双重entrySet	需要键值对的完整信息	高效，减少一次查找
Stream API	函数式处理需求	内存开销较大
迭代器	需要中途修改集合的场景	灵活但代码较复杂

4.2 实际应用建议

1. 优先使用entrySet：当需要同时访问键和值时，entrySet比keySet更高效
2. 避免多层嵌套Stream：超过两层的Stream可能影响可读性和性能
3. 考虑数据结构选择：对于频繁查询的场景，可考虑将嵌套Map转换为自定义类
4. 并行流处理：大数据量时可考虑并行流，但需注意线程安全

// 并行处理示例（需确保线程安全）
Map<String, Integer> result = departmentSalaries.parallelStream()
    .flatMap(deptEntry -> deptEntry.getValue().entrySet().stream())
    .collect(Collectors.toConcurrentMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        Integer::sum));

五、常见问题解决方案

5.1 空指针异常处理

// 安全遍历方式
Map<String, Map<String, Integer>> safeMap = new HashMap<>();
safeMap.computeIfAbsent("default", k -> new HashMap<>())
       .computeIfAbsent("item", k -> 0);
// 遍历时检查
safeMap.forEach((dept, employees) -> {
    employees.forEach((emp, salary) -> {
        if (dept != null && emp != null) {
            System.out.println(dept + ":" + emp + ":" + salary);
        }
    });
});

5.2 类型转换问题

// 使用泛型确保类型安全
Map<String, List<Map<Integer, String>>> typedMap = new HashMap<>();
try {
    List<Map<Integer, String>> list = typedMap.get("key");
    if (list != null) {
        Map<Integer, String> innerMap = list.get(0);
        String value = innerMap.get(1); // 安全访问
    }
} catch (ClassCastException e) {
    // 处理类型不匹配情况
}

六、总结与展望

Java集合的嵌套处理是开发复杂系统的必备技能，掌握嵌套集合、嵌套keySet和嵌套entrySet的遍历方法，能够显著提升数据处理效率。随着Java版本的演进，Stream API和并行处理为嵌套集合操作提供了更强大的工具，但开发者仍需根据具体场景选择最优方案。未来随着记录类（Records）和模式匹配等新特性的普及，嵌套集合的处理将变得更加简洁和安全。