How to compare objects by multiple fields

java

comparators

lambda-expressions

null-safety

byAlex Kataev·Oct 14, 2024

The goal is to compare objects by multiple fields? Look no further! With Java, you can achieve this by chaining Comparator.comparing and thenComparing.

// Create a high-speed, super-optimized comparator
Comparator<Person> comparator = Comparator
        .comparing(Person::getName)  // Sorting by name. It's all in the name, they say.
        .thenComparingInt(Person::getAge);  // Age before beauty? Not this time!

// Set the comparator in motion:
Collections.sort(peopleList, comparator);

First, you hit the primary field using Comparator.comparing. When the superhero battle ensues and there's a tie? thenComparingInt steps in for the tie-breaker, using the secondary field. This pattern can efficiently build a super-team of sorting criteria.

Java's Swiss-army knife for comparisons

Embracing Java 8's game-changers

Java 8 equips us with lambdas, our turbo-charged race cars for breezing through comparisons with efficiency and readability. This, combined with method references, simplifies the implementation of Comparable or Comparator without the burdensome boilerplate.

Crafting a powerful comparator

"Chains of love", they say? Here we talk of chains of comparisons! Combine Comparator.comparing() with its mate, thenComparing() to build complex comparators. Need specific field types? Use variants like thenComparingInt, thenComparingDouble, and thenComparingLong to cut out unnecessary boxing.

Null-proofing comparisons

Nobody wants the dreaded NullPointerException crashing the party! Ensure your comparators can safety-dance around null values using Comparator.nullsFirst or Comparator.nullsLast.

Cutting through complexity with libraries

Got a sorting beast that's getting out of hand? Guava's ComparisonChain and Apache Commons' CompareToBuilder can tame it with their fluent API, chaining comparisons and gracefully handling nulls, reducing error-prone code.

Spotlighting the simplicity in compareTo

A simple and clear compareTo method is not just a dream, but a necessity for maintainability. What's clear and readable wins the day; modern Java features or relevant libraries can achieve this.

Sharp comparisons

When in the battlefield of field priorities, order your chain based on field importance. Integer.compare or Double.compare saves the day for primitive fields, avoiding unnecessary autoboxing and boosting performance.

Comparisons: Pitfalls and Chainsaws

With chain-based sorting and reflective techniques, beware of the beast of errors and slow performance. The priority? Clarity over complexity. Avoid creating a Frankenstein of comparisons with unnecessary methods or excessive chaining.

ComparatorChain: The chain of command

ComparatorChain from Apache Commons or MultiComparator from Apache Collections are your star players when you're up against multiple comparison criteria. These players allow a structured chain of comparisons, reverseable for flexible sorting.

Thread-safety: Don't trip on the threads

With ComparatorChain, be sure to keep the chain immutable post-configuration to avoid UnsupportedOperationException. Always be mindful of thread-safety when distributing your comparators in a multitasking world.

explain-codes / Java / How to compare objects by multiple fields

Linked

"comparison method violates its general contract!"



Sort ArrayList of custom Objects by property



Sort a Map by values



How to sort a List/ArrayList?



How to get maximum value from the Collection (for example ArrayList)?

