Sorting Collections by Multiple Fields in Kotlin: 5 Fatal Mistakes

Why Does "Simple" Sorting in Kotlin Break Code?

Hello, colleague! If you've ever written in Kotlin and tried to sort a list of tasks first by date and then by priority, you've probably encountered a situation where the result looks like a random set. You're not alone — the question "Sort collection by multiple fields in Kotlin" has gathered thousands of views on Stack Overflow. It seems simple, right? But the devil, as always, is in the details.

In this article, we'll break down the top mistakes when sorting by multiple fields in Kotlin that even experienced developers make. You'll learn how sortedWith works, why compareBy and thenBy are your best friends, and how not to lose data due to null. Let's go!

Mistake #1: Sorting Like in Java — Using Comparator Manually

Kotlin is not Java. But many coming from the Java world write:

val list = listOf(\n    User("Alice", 25),\n    User("Bob", 20),\n    User("Charlie", 25)\n)\n\nval sorted = list.sortedWith(Comparator { a, b ->\n    val ageCompare = a.age.compareTo(b.age)\n    if (ageCompare != 0) ageCompare else a.name.compareTo(b.name)\n})\n

Yes, it works. But it's terribly unreadable, and you can easily get lost in chains of if-else. Kotlin offers an elegant way — comparator functions.

How to do it correctly?

val sorted = list.sortedWith(compareBy<User> { it.age }.thenBy { it.name })\n

Short, clear, no extra logic. compareBy creates the primary comparator, and thenBy adds secondary fields. This is sorting by multiple fields in Kotlin in its ideal form.

Mistake #2: Ignoring null When Sorting

Let's say we have a list of tasks where deadline can be null. If you simply write:

tasks.sortedBy { it.deadline }\n

…you'll get a NullPointerException. Kotlin is strict about null, and that's great. But what if null is normal?

Solution: nullsFirst / nullsLast

Use special wrappers:

val sorted = tasks.sortedWith(\n    compareBy<Task>(nullsLast()) { it.deadline }\n        .thenBy { it.priority }\n)\n

Here, nullsLast() places all null dates at the end of the list. There's also nullsFirst() — the opposite. This solves the problem, and your Kotlin collection sorting becomes safe.

Mistake #3: Confusion Between sortedBy and sortedWith

Many beginners write:

list.sortedBy { it.age }.sortedBy { it.name }\n

And are surprised that sorting by name "overrides" the sorting by age. sortedBy creates a new list each time and sorts only by one field. The last call is the main one.

How to fix it?

Use sortedWith with a compareBy chain:

list.sortedWith(compareBy({ it.age }, { it.name }))\n

Or a multi-line option for complex logic:

list.sortedWith(compareBy<Person> { it.age }.thenByDescending { it.name })\n

Remember: one call to sortedWith — one sort by multiple fields.

Mistake #4: Sorting in Reverse Order — in the Wrong Place

Sometimes you need to sort by age ascending, but by name descending. A typical mistake:

list.sortedByDescending { it.age }.sortedBy { it.name }\n

Again, the same problem — the second sort breaks the first. The correct approach:

val sorted = list.sortedWith(\n    compareBy<Person> { it.age }\n        .thenByDescending { it.name }\n)\n

Or for full control:

val sorted = list.sortedWith(\n    compareBy(Person::age).thenByDescending(Person::name)\n)\n<