How to use Comparator with conditions in java

Question

I am trying to sort a list based on sort key and sort order I receive from an API. For example, I have a list with sortkey and sortorder and based on that I need to sort.

List<SortList> sortlist;

I have a list of an object :

List<Employee> employee;

I am able to sort using

Collections.sort(sourceList, Comparator
                .comparing(Employee::getAge).reversed()
                .thenComparing(Employee::getCount));

But i need to check the sortfeild on a condition and based on that only the field is considered for sorting.

ex:

if(sortkey = "name") sortbythatkey from sortlist by the sort order

if (sortkey = "place") sortbythat key from sortlist by the sort order

So here if sortlist has both name and place then it should sort by both key and order

Any idea how could i achieve this?

Sort List contains:

{
    "sortKey":"name",
    "sortOrder":"ASC"

},
{
    "sortKey":"place",
    "sortOrder":"DESC"

}

Requirement is to chain them together like ORDER BY in SQL

Answer 1

You can create a method which when passed the sort key, you provide the proper Comparator:

public Comparator<Employee> getComparator(String sortKey) {
    if("name".equals(sortKey)) {
        return Comparator.comparing(Employee::getName);
    } else if ("place".equals(sortKey) {
        return Comparator.comparing(Employee::getPlace);
    } else {
        throw new IllegalArgumentException();
    }
}

To call it it would simply be:

Collections.sort(sourceList, getComparator(sortKey).reversed()
                .thenComparing(Employee::getCount));

While you could also write your own, I find it is better to delegate the "standard" parts and simply write the part that differs from this.

If you find yourself having many such sort keys, then a more suitable means to do this would be to use a map:

private static final Map<String, Comparator<Employee>> COMPARE_MAP = new HashMap<>() {{
    put.("name", Comparator.comparing(Employee::getName));
    put.("place", Comparator.comparing(Employee::getPlace));
}});

public Comparator<Employee> getComparator(String sortKey) {
    if(COMPARE_MAP.containsKey(sortKey)) {
        return COMPARE_MAP.get(sortKey);
    } else {
        throw new IllegalArgumentException();
    }
}

Reflection is also an option, but I would be cautious to use reflection unless it becomes impractical to do otherwise. In that case, you could create your own annotation to determine which fields of class Employee can be used for sorting.

Answer 2

Assuming that sortlist is a list of SortCriteria, which is a class like this:

class SortCritera {
    private String key;
    private String order;

    public String getKey() {
        return key;
    }

    public String getOrder() {
        return order;
    }

    // constructors, setters...
}

You first need a HashMap<String, Comparator<Employee>> to store all the corresponding comparators for each possible key:

HashMap<String, Comparator<Employee>> comparators = new HashMap<>();
comparators.put("name", Comparator.comparing(Employee::getName));
comparators.put("age", Comparator.comparing(Employee::getAge));
// ...

Then you can loop through the sortlist and keep calling thenComparing:

Comparator<Employee> comparator = comparators.get(sortlist.get(0).getKey());
if (sortlist.get(0).getOrder().equals("DESC")) {
    comparator = comparator.reversed();
}
for(int i = 1 ; i < sortlist.size() ; i++) {
    if (sortlist.get(i).getOrder().equals("DESC")) {
        comparator = comparator.thenComparing(comparators.get(sortlist.get(i).getKey()).reversed());
    } else {
        comparator = comparator.thenComparing(comparators.get(sortlist.get(i).getKey()));
    }
}
// now you can sort with "comparator".

As Holger has suggested, you can use the Stream API to do this as well:

sortlist.stream().map(sc -> {
    Comparator<Employee> c = comparators.get(sc.getKey()); 
    return sc.getOrder().equals("DESC")? c.reversed(): c; 
}).reduce(Comparator::thenComparing)
.ifPresent(x -> Collections.sort(originalList, x));