深入解析Java集合嵌套：嵌套集合与遍历策略详解

在Java开发中，集合框架（Collections Framework）是处理数据的核心工具。随着业务复杂度的提升，嵌套集合（如List嵌套List、Map嵌套Map）和嵌套遍历（如嵌套keySet、嵌套entrySet）成为开发中必须掌握的技能。本文将从嵌套集合的构建、嵌套keySet遍历、嵌套entrySet遍历三个维度展开，结合代码示例与性能优化建议，帮助开发者高效处理复杂数据结构。

一、嵌套集合的构建与操作

嵌套集合是指集合中包含其他集合作为元素，常见的形式包括：

• List嵌套List：如List<List<String>>
• Map嵌套Map：如Map<String, Map<String, Integer>>
• 混合嵌套：如Map<String, List<Integer>>

1.1 嵌套集合的初始化与填充

嵌套集合的初始化需注意泛型类型安全。以List<List<String>>为例：

List<List<String>> nestedList = new ArrayList<>();
List<String> innerList1 = new ArrayList<>();
innerList1.add("A");
innerList1.add("B");
nestedList.add(innerList1);
List<String> innerList2 = Arrays.asList("C", "D");
nestedList.add(innerList2);

对于Map嵌套，需逐层初始化：

Map<String, Map<String, Integer>> nestedMap = new HashMap<>();
Map<String, Integer> innerMap = new HashMap<>();
innerMap.put("key1", 1);
innerMap.put("key2", 2);
nestedMap.put("outerKey", innerMap);

1.2 嵌套集合的常见操作

• 遍历嵌套List：使用双重循环

  for (List<String> innerList : nestedList) {
    for (String item : innerList) {
        System.out.println(item);
    }
  }

• 修改嵌套Map的值：需先获取内层Map的引用

  nestedMap.get("outerKey").put("key3", 3); // 直接修改

• 深度拷贝嵌套集合：需递归实现或使用第三方库（如Apache Commons Lang的SerializationUtils.clone()）

1.3 性能与注意事项

• 内存开销：嵌套集合会显著增加内存占用，需合理设计数据结构。
• 线程安全：若多线程访问，需使用Collections.synchronizedList()或ConcurrentHashMap。
• 空指针风险：访问内层集合前需判空，或使用Optional避免NPE。

二、嵌套keySet遍历：高效访问键集合

当处理Map<String, Map<String, Integer>>时，需遍历外层Map的keySet，再遍历内层Map的keySet。

2.1 基础遍历方法

Map<String, Map<String, Integer>> nestedMap = ...; // 初始化数据
for (String outerKey : nestedMap.keySet()) {
    System.out.println("Outer Key: " + outerKey);
    Map<String, Integer> innerMap = nestedMap.get(outerKey);
    for (String innerKey : innerMap.keySet()) {
        System.out.println("  Inner Key: " + innerKey + 
                          ", Value: " + innerMap.get(innerKey));
    }
}

2.2 优化建议

• 避免重复get操作：内层Map的get(innerKey)可提前缓存

  for (String outerKey : nestedMap.keySet()) {
    Map<String, Integer> innerMap = nestedMap.get(outerKey);
    for (String innerKey : innerMap.keySet()) {
        Integer value = innerMap.get(innerKey); // 缓存结果
        // 处理value
    }
  }

• 使用Java 8+的forEach：简化代码

  nestedMap.forEach((outerKey, innerMap) -> {
    System.out.println("Outer Key: " + outerKey);
    innerMap.forEach((innerKey, value) -> {
        System.out.println("  Inner Key: " + innerKey + 
                          ", Value: " + value);
    });
  });

2.3 适用场景

• 仅需访问键时（如检查键是否存在）
• 内层Map的value计算成本较高时（避免提前获取value）

三、嵌套entrySet遍历：键值对的高效处理

若需同时访问键和值，entrySet是更优选择。对于嵌套Map，需遍历外层entrySet，再遍历内层entrySet。

3.1 基础遍历方法

Map<String, Map<String, Integer>> nestedMap = ...; // 初始化数据
for (Map.Entry<String, Map<String, Integer>> outerEntry : nestedMap.entrySet()) {
    String outerKey = outerEntry.getKey();
    Map<String, Integer> innerMap = outerEntry.getValue();
    System.out.println("Outer Key: " + outerKey);
    for (Map.Entry<String, Integer> innerEntry : innerMap.entrySet()) {
        System.out.println("  Inner Key: " + innerEntry.getKey() + 
                          ", Value: " + innerEntry.getValue());
    }
}

3.2 优化建议

• 减少对象创建：避免在循环中创建临时对象（如字符串拼接）
• 并行流处理：若数据量大且无顺序要求，可使用并行流

  nestedMap.entrySet().parallelStream().forEach(outerEntry -> {
    String outerKey = outerEntry.getKey();
    Map<String, Integer> innerMap = outerEntry.getValue();
    // 处理逻辑
  });

• 过滤与转换：结合Stream API实现复杂操作

  nestedMap.entrySet().stream()
    .filter(outerEntry -> outerEntry.getKey().startsWith("A"))
    .flatMap(outerEntry -> outerEntry.getValue().entrySet().stream())
    .forEach(innerEntry -> {
        // 处理过滤后的键值对
    });

3.3 适用场景

• 需同时访问键和值时（如统计、转换）
• 内层Map的value类型复杂时（避免重复解包）

四、综合案例：嵌套集合的实际应用

案例：统计学生成绩

假设数据结构为Map<String, Map<String, Integer>>，其中外层Map的key为班级名，内层Map的key为学生名，value为成绩。

4.1 需求：计算每个班级的平均分

Map<String, Map<String, Integer>> classScores = ...; // 初始化数据
// 方法1：使用嵌套entrySet
classScores.forEach((className, studentScores) -> {
    double sum = studentScores.values().stream()
        .mapToInt(Integer::intValue)
        .sum();
    double avg = sum / studentScores.size();
    System.out.println(className + "的平均分: " + avg);
});
// 方法2：使用嵌套keySet（需额外get操作）
classScores.forEach((className, studentScores) -> {
    int sum = 0;
    for (String student : studentScores.keySet()) {
        sum += studentScores.get(student);
    }
    double avg = (double) sum / studentScores.size();
    System.out.println(className + "的平均分: " + avg);
});

4.2 性能对比

• entrySet：直接访问值，无需额外get操作，性能更优。
• keySet：需通过key获取value，若内层Map较大，性能较差。

五、总结与最佳实践

1. 嵌套集合设计：

   • 根据业务需求选择嵌套深度，避免过度嵌套。
   • 使用不可变集合（如Collections.unmodifiableList）保护数据。

2. 遍历策略选择：

   • 仅需键时：优先使用keySet。
   • 需键值对时：优先使用entrySet。
   • 数据量大时：考虑并行流处理。

3. 性能优化：

   • 减少循环内的重复操作（如重复get）。
   • 使用Java 8+的Stream API简化代码。
   • 注意线程安全问题。

4. 代码可读性：

   • 避免过深的嵌套循环，可拆分为方法。
   • 使用有意义的变量名（如outerEntry、innerEntry）。

通过合理设计嵌套集合与遍历策略，开发者可以高效处理复杂数据结构，提升代码性能与可维护性。