Remove a list of user-defined class object and combine value of one property in Java

I have a Employee class

class Employee {

    private final String id;
    private float compensation;

    public Employee(String id, float compensation) {
        this.id = id;
        this.compensation = compensation;
    }

    public String getId() {
        return id;
    }
    
    public float getCompensation() {
        return compensation;
    }
}

Then I have a list of Employees

List<Employee> payment = Arrays.asList(
      new Employee("1", 3000.00),
      new Employee("1", 6000.00),
      new Employee("2", 5000.00),
      new Employee("3", 4000.00),
);

How to dedup the list by the employee ID and combine the compensation?

Expected result:

List<Employee> newPayment = Arrays.asList(
      new Employee("1", 9000.00),
      new Employee("2", 5000.00),
      new Employee("3", 4000.00),
);

You can use Java 8 streams and collectors to group the employees by their id and then sum their compensations. Here's an example code snippet:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


class Dedup {
    public static List<Employee> dedupByIds(List<Employee> payment) {
        return payment.stream()
                .collect(Collectors.groupingBy(Employee::getId, Collectors.summingDouble(Employee::getCompensation)))
                .entrySet().stream()
                .map(entry -> new Employee(entry.getKey(), entry.getValue().floatValue()))
                .collect(Collectors.toList());
    }
}

and then call this function by the list that you want to dedup.

List<Employee> payment = Arrays.asList(
                new Employee("1", 3000.00f),
                new Employee("1", 6000.00f),
                new Employee("2", 5000.00f),
                new Employee("3", 4000.00f)
                );

List<Employee> newPayment = Dedup.dedupByIds(payment);

//printing values to console 
for (Employee e : newPayment) {
    System.out.println(e.getId() + " : " + e.getCompensation());
}

To dedup the list by employee ID and combine the compensation, you can use Java streams and grouping operations. Here's an example:

List<Employee> newPayment = payment.stream()
        .collect(Collectors.groupingBy(Employee::getId,
                 Collectors.summingDouble(Employee::getCompensation)))
        .entrySet().stream()
        .map(entry -> new Employee(entry.getKey(), (float) entry.getValue()))
        .collect(Collectors.toList());

In this code, we first use the groupingBy() collector to group the Employee objects by their id property. We also use the summingDouble() collector to calculate the sum of compensation for each group.

This creates a Map<String, Double> where the keys are the employee IDs and the values are the total compensations for each group.

Next, we convert the map entries back to Employee objects using the map() method, and finally collect them into a new list using the toList() collector. The result is a new list of Employee objects with the combined compensations.