如何使用Java 8去除员工组件列表中的重复项

原模型类 #

public class Employee {
    private int empId;
    private Components components;
}

public class Components{
    private int cmpid;
    private String cmpName;
}

数据库返回的原始JSON响应 #

{
  "Employee": [
    {
      "empId": 30594,      
      "components": {
        "cmpid": 1,
        "cmpName": "ABC"
      }
    },
    {
      "empId": 30594,      
      "components": {
        "cmpid": 1,
        "cmpName": "ABC"
      }
    },
    {
      "empId": 30594,      
      "components": {
        "cmpid": 2,
        "cmpName": "BCD"
      }
    }
  ]
}

目标模型类 #

public class EmployeeConverter {
    private int employeeID;
    private List<Components> components;
}

目标JSON格式 #

{
  "EmployeeConverter": [
    {
      "empId": 30594,      
      "components": [
        {
          "cmpid": 1,
          "cmpName": "ABC"
        },
        {
          "cmpid": 2,
          "cmpName": "BCD"
        }                
      ]
    }
  ]
}

Java 8实现方案 #

可以借助Stream API的分组、映射能力完成转换，核心是按empId聚合员工数据，并对关联的Components去重。

1. 为Components类实现equals和hashCode #

要实现Components去重，需要让JVM能识别两个对象是否为重复项，因此重写这两个方法：

public class Components{
    private int cmpid;
    private String cmpName;

    // 构造方法、Getter、Setter省略

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Components that = (Components) o;
        return cmpid == that.cmpid && Objects.equals(cmpName, that.cmpName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(cmpid, cmpName);
    }
}

2. Stream API转换代码 #

假设已将原始JSON解析为List<Employee>对象列表（命名为employeeList），转换逻辑如下：

List<EmployeeConverter> result = employeeList.stream()
    // 按empId分组，将相同ID的Employee归为一组
    .collect(Collectors.groupingBy(Employee::getEmpId))
    .entrySet()
    .stream()
    .map(entry -> {
        EmployeeConverter converter = new EmployeeConverter();
        converter.setEmployeeID(entry.getKey());
        // 提取分组内的Components，去重后转为List
        List<Components> uniqueComponents = entry.getValue().stream()
            .map(Employee::getComponents)
            .distinct()
            .collect(Collectors.toList());
        converter.setComponents(uniqueComponents);
        return converter;
    })
    .collect(Collectors.toList());

替代方案（不重写equals/hashCode） #

如果不想修改Components类，可以用自定义去重逻辑：

List<EmployeeConverter> result = employeeList.stream()
    .collect(Collectors.groupingBy(Employee::getEmpId))
    .entrySet()
    .stream()
    .map(entry -> {
        EmployeeConverter converter = new EmployeeConverter();
        converter.setEmployeeID(entry.getKey());
        // 用自定义规则去重
        List<Components> uniqueComponents = entry.getValue().stream()
            .map(Employee::getComponents)
            .filter(distinctByKey(c -> Arrays.asList(c.getCmpid(), c.getCmpName())))
            .collect(Collectors.toList());
        converter.setComponents(uniqueComponents);
        return converter;
    })
    .collect(Collectors.toList());

// 自定义去重工具方法
private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}

内容的提问来源于stack exchange，提问作者java_tech