如何基于对象字段对 List 进行分组并生成嵌套列表

本文介绍如何根据 `obj` 对象的 `shape`、`size` 或二者组合，将 `list` 动态分组为 `list>`，并适配不同业务类型（如 type_1/type_2/type_3）的分组策略，使用 java 8 stream + collectors 实现简洁、可读性强的分组逻辑。

在实际开发中，我们常需按对象的某个或多个属性对集合进行逻辑分组（例如归类相同形状、尺寸或组合条件的物品），最终得到一个“分组后的子列表集合”——即 List>。Java 8 的 Stream API 结合 Collectors.groupingBy 可以优雅地完成这一任务，无需手动遍历和嵌套 Map 构建。

✅ 核心思路：用 groupingBy 提取分组键，再转为 List>

Collectors.groupingBy 会返回 Map>，其 values 视图即为我们所需的 Collection>，只需用 new ArrayList(...) 包装即可获得 List>。

假设 Obj 类已提供标准 getter 方法（务必确保 getShape()、getSize() 存在且正确）：

public class Obj {
    private String size;
    private String shape;
    private String name;

    // 构造函数、getter（关键！）、setter 省略
    public String getShape() { return shape; }
    public String getSize() { return size; }
}

? 按单字段分组（如 type_1 → shape）

List> groupByShape(List objs) {
    return new ArrayList<>(
        objs.stream()
            .collect(Collectors.groupingBy(Obj::getShape))
            .values()
    );
}

? 按另一字段分组（如 type_2 → size）

List> groupBySize(List objs) {
    return new ArrayList<>(
        objs.stream()
            .collect(Collectors.groupingBy(Obj::getSize))
            .values()
    );
}

? 按多字段组合分组（如 type_3 → shape + size）

推荐使用 复合键对象 或 匿名记录（Java 14+），但为兼容性与清晰性，建议定义轻量级键类或使用 Map.entry（Java 9+）：

✅ 推荐方式（Java 9+，简洁安全）：

元典智库

元典智库：智能开放的法律搜索引擎

下载

List> groupByShapeAndSize(List objs) {
    return new ArrayList<>(
        objs.stream()
            .collect(Collectors.groupingBy(
                obj -> Map.entry(obj.getShape(), obj.getSize())
            ))
            .values()
    );
}

✅ 兼容 Java 8 方式（使用自定义键类）：

// 内部静态类，确保 equals/hashCode 正确实现
private static class ShapeSizeKey {
    final String shape;
    final String size;
    ShapeSizeKey(String shape, String size) {
        this.shape = shape;
        this.size = size;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ShapeSizeKey that = (ShapeSizeKey) o;
        return Objects.equals(shape, that.shape) &&
               Objects.equals(size, that.size);
    }
    @Override
    public int hashCode() {
        return Objects.hash(shape, size);
    }
}

// 使用示例
List> groupByShapeAndSize(List objs) {
    return new ArrayList<>(
        objs.stream()
            .collect(Collectors.groupingBy(
                obj -> new ShapeSizeKey(obj.getShape(), obj.getSize())
            ))
            .values()
    );
}

? 整合进主函数：动态分组调度

将上述方法集成到你的 functionName 中，保持逻辑清晰、可维护：

void functionName(Map> objMap) {
    objMap.forEach((type, objs) -> {
        List> groupedLists;
        switch (type) {
            case "type_1":
                groupedLists = groupByShape(objs);
                processGrouped(groupedLists); // 自定义后续处理
                break;
            case "type_2":
                groupedLists = groupBySize(objs);
                processGrouped(groupedLists);
                break;
            case "type_3":
                groupedLists = groupByShapeAndSize(objs);
                processGrouped(groupedLists);
                break;
            default:
                throw new IllegalArgumentException("Unknown type: " + type);
        }
    });
}

// 示例处理方法（可按需替换）
private void processGrouped(List> groups) {
    for (int i = 0; i < groups.size(); i++) {
        System.out.println("Group " + (i + 1) + ": " + groups.get(i).size() + " objects");
        // 如：计算每组统计、生成报告、调用领域服务等
    }
}

⚠️ 注意事项与最佳实践

• ✅ Getter 必须存在且公开：groupingBy(Obj::getShape) 依赖 public String getShape()；若字段为 private 但无 getter，编译失败。
• ✅ 空值安全：若 shape 或 size 可能为 null，groupingBy 默认将 null 作为独立键分组；如需跳过空值，加 .filter(obj -> obj.getShape() != null)。
• ✅ 性能提示：对于超大列表（>10⁵），流式分组仍高效；若极致性能敏感，可考虑预分配 HashMap + 手动 computeIfAbsent，但通常不必要。
• ✅ 不可变性考量：返回的 List> 中内层 List 是 ArrayList，可安全修改；若需不可变视图，可用 Collections.unmodifiableList 包装。

通过以上方式，你不仅能精准满足 type_1/type_2/type_3 的分组需求，还能轻松扩展支持 name、size+name 等任意组合，真正实现「配置驱动分组逻辑」的可维护架构。