Considere, tengo la siguiente clase.
public class Employee { private Integer id; private Integer parentId; private int value; }Ahora tengo los siguientes registros.
Employee employee1 = new Employee(1, null, 4); Employee employee2 = new Employee(2, 1, 4); Employee employee3 = new Employee(3, null, 8); Employee employee4 = new Employee(4, 1, 3); Employee employee5 = new Employee(5, 2, 11); Entonces, parentId es la id de un empleado que es el jefe de otro empleado .
La cuestión es averiguar la suma del valor de un empleado y su padre, si lo tiene, o devolver el valor tal como está. Entonces, en este caso, el resultado debería ser.
| identificación | valor |
|---|---|
| 1 | 4 |
| 2 | 8 |
| 3 | 8 |
| 4 | 7 |
| 5 | 15 |
¿Cómo lograr esto usando flujos de Java 8? He probado lo siguiente;
Optional<Integer> first = employees.stream().map(a -> { int sum = 0; employees.stream().map(b -> { if (Objects.equals(a.id, b.parentId)) { sum = sum + a.value + b.value; }else{ sum = sum + a.value; } return sum; }); return sum; } ).findFirst();Pero recibo un error con la variable de suma que debería ser final o efectivamente final.
Al calcular solo el valor del hijo y su primer padre, puede hacerlo con un filtro simple en la lista.
@Test public void test() { final Employee employee1 = new Employee(1, null, 4); final Employee employee2 = new Employee(2, 1, 4); final Employee employee3 = new Employee(3, null, 8); final Employee employee4 = new Employee(4, 1, 3); final Employee employee5 = new Employee(5, 2, 11); final List<Employee> employees = List.of(employee1, employee2, employee3, employee4, employee5); final List<Pair<Integer, Integer>> res = employees .stream() .map(emp -> Pair.of(emp.id, emp.value + employees .stream() .filter(e -> e.id.intValue() == Optional.ofNullable(emp.parentId).orElse(-1)) .findFirst().map(Employee::getValue) .orElse(0) ) ) .collect(Collectors.toList()); res.forEach(System.out::println); } public class Employee { public Integer id; public Integer parentId; public int value; public Employee(final Integer id, final Integer parentId, final int value) { this.id = id; this.parentId = parentId; this.value = value; } public int getValue() { return this.value; } }resultado:
(1,4) (2,8) (3,8) (4,7) (5,15) NB: el objeto Pair que utilicé proviene de org.apache.commons.lang3.tuple.Pair
La forma más eficiente de lograrlo es crear un mapa que permita recuperar el value de un Employee por su id .
Luego, para combinar el value de cada Employee con el value de su padre, use el valor del mapa o 0 si el padre es null .
El método a continuación genera un mapa con la id utilizada como clave y el value del empleado como valor .
public static Map<Integer, Integer> getEmplValueById(List<Employee> employees) { return employees.stream() .collect(Collectors.toMap(Employee::getId, Employee::getValue)); } El siguiente método crea un mapa con id utilizado como clave y el valor total de un empleado como valor de un mapa.
public static Map<Integer, Integer> getEmplSumById(List<Employee> employees, Map<Integer, Integer> valueById) { return employees.stream() .collect(Collectors.toMap(Employee::getId, empl -> empl.getValue() + valueById.getOrDefault(empl.getParentId(), 0))); } main()
public static void main(String[] args) { List<Employee> employees = List.of( new Employee(1, null, 4), new Employee(2, 1, 4), new Employee(3, null, 8), new Employee(4, 1, 3), new Employee(5, 2, 11)); Map<Integer, Integer> valueById = getEmplValueById(employees); getEmplSumById(employees, valueById) .forEach((k, v) -> System.out.printf("ID %d \t value %d\n", k, v)); }Producción
ID 1 value 4 ID 2 value 8 ID 3 value 8 ID 4 value 7 ID 5 value 15