Stream: Sorting & Comparator

sorted() is a stateful intermediate operation that buffers ALL elements in O(n) memory, blocks fusion, and hangs on infinite streams; filter/map are stateless with O(1) memory.

Chain Comparator.comparing(primaryKey).thenComparing(secondaryKey) for multi-field sorting, and use reverseOrder() for descending on a specific field.

Use Comparator.comparingInt(String::length) for ascending length sort, .reversed() for descending, and thenComparing(naturalOrder()) for alphabetical tiebreak on equal lengths.

Java 8's Comparator fluent API builds complex sort orders declaratively with comparing, thenComparing, reversed, and nullsFirst/nullsLast, replacing verbose manual compare methods.

Comparable defines one natural ordering inside the class via compareTo, while Comparator defines unlimited external ordering strategies outside the class via compare.

`groupingBy(classifier, TreeMap::new, downstream)` groups into a map whose keys stay sorted, instead of the unordered default `HashMap`.

`groupingBy(word, counting())` gives a count per key; sort the entries by value descending to rank them.

`comparing(key).thenComparing(nextKey)...` layers sort keys, each breaking ties left by the previous, with `reversed` for a descending key.

groupingBy(city, collectingAndThen(toList(), sort by salary desc)) buckets by city and orders each bucket highest first.

stream().max(Comparator.comparingInt(String::length)) returns the longest string as an Optional, using a single pass with a primitive int extractor.

`reduce(maxBy(comparator))` keeps the larger of each pair to find the maximum; `Stream.max(comparator)` is the direct shorthand.

distinct().sorted(Comparator.reverseOrder()).skip(k-1).findFirst() returns the Kth largest distinct value as an Optional.

Stream.concat(a.stream(), b.stream()).sorted().toList() appends both streams and sorts the combined result into a single ordered list.

map(n -> n * n).sorted().toList() squares each integer and sorts the results in ascending order.

`sorted(Comparator.comparing(Employee::getSalary))` orders employees from lowest salary to highest.

`Comparator.comparing(Employee::getSalary).reversed()` orders employees from highest salary to lowest.

Sort names with `String.CASE_INSENSITIVE_ORDER` so capitals and lowercase are ordered together.

`comparing(dept).thenComparing(salary, reverseOrder())` means sort by department, then break ties by salary highest-first.

`comparingInt(age).thenComparing(name)` sorts by age, then breaks age-ties alphabetically.

`comparingInt(year).reversed()` puts the latest-joining employees at the top.

`comparing(salary).reversed()` means order by salary, then flip it so the highest comes first.

`comparingInt(String::length)` orders strings shortest-to-longest by character count.

`nullsLast(naturalOrder())` sorts real values normally and pushes nulls to the end instead of crashing.