java 8 stream用于根据特定字段对对象列表进行排序

Question

I have a scenario to sort the objects based on timestamp. The classes are as follows:

class Employee 
{
    private String name;
    private List<Address> addresses;

    //...
    //Getters and setters for all fields
}

public class Address
{
    private String city;
    private Timestamp startDate;
    private Timestamp endDate;
    private String typeOfResidence;

    //...
    //Getters and setters for all the fields
}

For an employee, there are 2 possibilities 1. it will have a list of address. 2. the list of address can be null

The address class has a field typeOfResidence which can have values such as Residence, Office, ForeignHome.

Each Employee can have list of address, one address will be Residential, other Office and so on. There can be multiple Residential addresses but only one Office address.

I want to sort the list of employees based on startDate of Address whose typeOfResidence=Office.

I have written the following code:

private void sortEmployeeListBasedOnStartDate(List<Employee> employeeList)
{
    Comparator<Address> byTimeStamp = Comparator.comparing(
        Address::getStarteDate,
        (ts1, ts2) -> ts1.toGregorianCalendar().compareTo(ts2.toGregorianCalendar())
    );

    employeeList.stream()
        .map(x -> getLatestAddressByType(x, "Office"))
        .filter(y -> y!=null)
        .sorted(byTimeStamp.reversed())
        .collect(Collectors.toList());
}

public Address getLatestAddressByType(Employee employee, String type)
{
    if(role != null && brokerageManagedProposalType != null)
    {
         return getUserAddress(employee).stream()
            .filter(address-> address.getTypeOfResidence().equals(type))
            .findFirst()
            .orElse(null);
    }
    return null;
}

public List<Address> getUserAddress(Employee employee)
{
    if (!NullChecker.isNull(employee) && !NullChecker.isNull(employee.getAddress()))
    {
        return employee.getAddress();
    }
    return Collections.emptyList();
}

Somehow this does not seem to be working. The employees are not sorted. Please help me to make it working.

Answer 1

Your sortEmployeeListBasedOnStartDate method doesn't mutate the input List<Employee> . It creates a new sorted List<Address> , which you do nothing with.

If you want a sorted List<Employee> , you shouldn't be mapping the Employee s to Address es. You should produce a sorted List<Employee> and return that List .

Something like this should do:

private List<Employee> sortEmployeeListBasedOnStartDate(List<Employee> employeeList)
{
    Comparator<Address> byTimeStamp = Comparator.comparing(
        Address::getStarteDate,
        (ts1, ts2) -> ts1.toGregorianCalendar().compareTo(ts2.toGregorianCalendar())
    );

    return employeeList
        .stream()
        .sorted((e1,e2)->byTimeStamp.compare(getLatestAddressByType(e2, "Office"),getLatestAddressByType(e1, "Office")))
        .collect(Collectors.toList());
}

You might have to add some handling for the case where getLatestAddressByType() returns null :

    return employeeList
        .stream()
        .filter(e->getLatestAddressByType(e, "Office") != null)
        .sorted((e1,e2)->byTimeStamp.compare(getLatestAddressByType(e2, "Office"),getLatestAddressByType(e1, "Office")))
        .collect(Collectors.toList());

Answer 2

If you want in-place sorting, you can use Collections.sort instead of streams.

Collections.sort(employeeList, 
    (e1,e2) -> byTimeStamp.compare(
        getLatestAddressByType(e2, "Office"),
        getLatestAddressByType(e1, "Office") );

Similarly, the null -filtering issue can be solved in-place as follows:

employeeList.removeIf(e -> getLatestAddressByType(e, "Office") == null);

(btw, getLatestAddressByType should probably be an instance method of Employee )

Answer 3

Your problem is here:

employeeList.stream()
    .map(x -> getLatestAddressByType(x, "Office"))
    .filter(y -> y!=null)
    .sorted(byTimeStamp.reversed())
    .collect(Collectors.toList());

This is not an in-place sort. The values in employeeList remain exactly the same. collect is creating a new List instance which is never assigned to a variable or returned - the instance is simply created and then immediately illegible for garbage collection.