Obtenir des employés avant et après la date précise d'adhésion à partir de la liste des employés avec le flux Java

J'ai Listdes Employees avec différentes dates d'adhésion. Je souhaite obtenir des employés avant et après une date précise d'adhésion à partir de la liste à l'aide de flux.

j'ai essayé de suivre le code,

 List<Employee> employeeListAfter = employeeList.stream()
                .filter(e -> e.joiningDate.isAfter(specificDate))
                .collect(Collectors.toList());

List<Employee> employeeListBefore = employeeList.stream()
        .filter(e -> e.joiningDate.isBefore(specificDate))
        .collect(Collectors.toList());

class Employee{
    int id;
    String name;
    LocalDate joiningDate;
}

Existe-t-il un moyen de le faire en un seul flux?

Vous pouvez utiliser partitioningBycomme ci-dessous,

Map<Boolean, List<Employee>> listMap = employeeList.stream()
        .collect(Collectors.partitioningBy(e -> e.joiningDate.isAfter(specificDate)));

List<Employee> employeeListAfter = listMap.get(true);
List<Employee> employeeListBefore = listMap.get(false);

partitioningBy Renvoie un collecteur qui partitionne les éléments d'entrée en fonction d'un prédicat et les organise en unMap<Boolean, List<T>>

Notez que cela ne gérera pas les employés avec specificDate.

Si votre liste peut contenir des entrées qui se sont jointes à laspecificDate , vous pouvez trouver groupingByutile:

Map<Integer, List<Employee>> result = employeeList.stream()
    .map(emp -> new AbstractMap.SimpleEntry<>(specificDate.compareTo(emp.getJoiningDate()), emp))
    .collect(Collectors.groupingBy(entry -> entry.getKey() > 0 ? 1 : (entry.getKey() < 0 ? -1 : 0),
            Collectors.mapping(entry -> entry.getValue(), Collectors.toList())));

employeeListAfter = result.get(-1);
employeeListBefore = result.get(1);
employeeListOnSpecificDate = result.get(0);

La resultcarte contient des Employeeenregistrements regroupés par position par rapport à specificDate, de sorte que vous pouvez choisir qui s'est joint avant, après ou à la date spécifiée.

Vous devez filtrer les employés avec cette date particulière. Ensuite, vous pouvez utiliser le partitionnement:

Map<Boolean, List<Employee>> partitioned = employeeList.stream()
    .filter(e -> !e.joiningDate.equals(specificDate))
    .collect(partitioningBy(e -> e.joiningDate.isAfter(specificDate)));

List<Employee> employeeListAfter = partitioned.get(true);
List<Employee> employeeListBefore = partitioned.get(false);

Cela créera une carte des collections en fonction de si elles remplissent le prédicat.

Vous pouvez utiliser Collectors.groupingByet utiliser la compareTométhode pour regrouper la liste des employés en fonction de la date précédente, actuelle et future

Map<Integer, List<Employee>> result = employeeList.stream()
            .collect(Collectors.groupingBy(e-> e.joiningDate.compareTo(specificDate)< 0 ? -1 : (e.joiningDate.compareTo(specificDate) == 0 ? 0 : 1)));

Ainsi, la sortie sera

key--> -1 ---> will have employees with previous date
key--> 0 ---> will have employees with current date
key--> 1 ---> will have employees with future date