Sorting Java Collections: Evolution and Practice from Comparator to Lambda Expressions

Fundamentals of Java Collection Sorting

Sorting collections is a common requirement in Java programming. The user's question involves sorting a Collection<CustomObject> by the id field. Although the Collection interface does not directly support sorting, it can be addressed by converting to a List or using specific implementation classes.

Traditional Comparator Implementation

Early Java versions implemented custom sorting through the Comparator interface. Anonymous inner classes define comparison logic:

List<CustomObject> list = new ArrayList<>();
Comparator<CustomObject> comparator = new Comparator<CustomObject>() {
    @Override
    public int compare(CustomObject left, CustomObject right) {
        return left.getId() - right.getId();
    }
};
Collections.sort(list, comparator);

If CustomObject implements the Comparable interface, Collections.sort(list) can be called directly. However, this approach results in verbose code, especially in multiple sorting scenarios.

Simplification with Java 8 Lambda Expressions

Java 8 introduced Lambda expressions, significantly simplifying sorting code. Using Collections.sort with Lambda:

List<CustomObject> list = getCustomObjectList();
Collections.sort(list, (left, right) -> left.getId() - right.getId());

Further simplification by directly using the List.sort method:

list.sort((left, right) -> left.getId() - right.getId());

The most concise approach utilizes the Comparator.comparing method reference:

list.sort(Comparator.comparing(CustomObject::getId));

This method is type-safe and easy to maintain.

Sorting Strategies for Different Collection Types

For Collection types, conversion to List is necessary:

Collection<CustomObject> collection = getCollection();
List<CustomObject> list = new ArrayList<>(collection);
list.sort(Comparator.comparing(CustomObject::getId));

For Set, TreeSet can be used for automatic sorting:

Set<CustomObject> set = getSet();
Set<CustomObject> sortedSet = new TreeSet<>(Comparator.comparing(CustomObject::getId));
sortedSet.addAll(set);

If elements implement Comparable, simply use new TreeSet<>(set).

Performance and Best Practices

Sorting algorithms typically use TimSort (Java 7+), with an average time complexity of O(n log n). For large datasets, consider parallel sorting:

list.parallelStream().sorted(Comparator.comparing(CustomObject::getId)).collect(Collectors.toList());

Note that Comparator should handle null values to avoid NullPointerException. Use Comparator.nullsFirst or Comparator.nullsLast:

list.sort(Comparator.comparing(CustomObject::getId, Comparator.nullsFirst(Comparator.naturalOrder())));

Multi-field sorting can be achieved through chained thenComparing calls.