Sort by Multiple Fields in Kotlin: sortedBy, thenBy, and compareBy

By the end of this page, you will understand how multi-field sorting works in Kotlin, why chaining sortedBy is usually the wrong approach for this problem, and how to correctly sort using compareBy, thenBy, and sortedWith. You will also see practical examples and common patterns used in real Kotlin codebases.

In Kotlin, sorting by multiple fields means defining a primary sort key and one or more secondary sort keys.

In your example:

• Primary key: age
• Secondary key: name

That means:

1. Compare two people by age
2. If their ages are different, use that result
3. If their ages are the same, compare by name

Kotlin does this with a comparator. A comparator is an object or function that tells Kotlin how two values should be ordered.

The most common beginner-friendly way to sort by multiple fields is:

list.sortedWith(compareBy<Person> { it.age }.thenBy { it.name })

This creates a comparator that:

• sorts by age first
• then sorts by name when ages are equal

Why this matters in real programming:

• You often sort users by last name then first name
• You sort products by category then price
• You sort log entries by date then severity
• You sort API results by status then timestamp

Multi-field sorting is a very common data-handling task, so understanding comparator-based sorting is an important Kotlin skill.

Think of sorting like organizing papers in a filing cabinet.

• First, you place papers into drawers by age
• Inside each drawer, you arrange the papers by name

So if two people are both 20 years old, they go into the same age drawer, and then their names decide their order.

Using sortedBy twice is like first organizing by age, then taking the whole stack and reorganizing everything by name only. The second rule becomes the main visible order, which is not the same as saying “sort by age, then by name.”

A comparator is like a set of instructions for a clerk:

1. Check age first
2. If ages match, check name
3. If names also match, treat them as equal for sorting

Core syntax

The standard Kotlin approach is:

val sortedList = list.sortedWith(
    compareBy<Person> { it.age }.thenBy { it.name }
)

Example

data class Person(val age: Int, val name: String)

fun main() {
    val list = listOf(
        Person(25, "Tom"),
        Person(25, "Dave"),
        Person(20, "Kate"),
        Person(20, "Alice")
    )

    val sortedList = list.sortedWith(
        compareBy<Person> { it.age }.thenBy { it.name }
    )

    println(sortedList)
}

Output:

[Person(age=20, name=Alice), Person(age=20, name=Kate), Person(age=25, name=Dave), Person(age=25, name=Tom)]

Shorter form

Kotlin also supports passing multiple selectors to compareBy:

Consider this code:

data class Person(val age: Int, val name: String)

val list = listOf(
    Person(25, "Tom"),
    Person(25, "Dave"),
    Person(20, "Kate"),
    Person(20, "Alice")
)

val sortedList = list.sortedWith(
    compareBy<Person> { it.age }.thenBy { it.name }
)

Here is what the comparator does step by step:

1. Compare Person(25, "Tom") and Person(25, "Dave")

• Ages are both 25
• Since ages are equal, compare names
• "Dave" comes before "Tom"

2. Compare Person(20, "Kate") and Person(25, "Dave")

• 20 is less than 25
• So comes first

Multi-field sorting appears in many real applications.

User lists

Sort users by:

• lastName, then firstName
• role, then username
• createdAt, then id

E-commerce

Sort products by:

• category, then price
• availability, then rating
• brand, then name

Logging and monitoring

Sort log entries by:

• date, then severity
• service, then timestamp

Reporting and analytics

Sort rows by:

In real Kotlin projects, developers usually use comparator chains for clarity and maintainability.

Common pattern: comparator chain

val personComparator = compareBy<Person> { it.age }
    .thenBy { it.name }

This is useful when the same ordering is reused in several places.

Sorting before display

val visibleUsers = users
    .filter { it.isActive }
    .sortedWith(compareBy<User> { it.lastName }.thenBy { it.firstName })

This pattern often appears in UI code, reports, and APIs.

Guarding against null values

When some fields may be null, developers often decide on a rule explicitly.

data class User(val age: Int?, val name: String)

val sorted = users.sortedWith(
    compareBy<User> { it.age ?: Int.MAX_VALUE }
        .thenBy { it.name }
)

This pushes users with unknown age to the end.

In-place sorting for mutable collections

people.sortWith(compareBy<Person> { it.age }.thenBy { it.name })

This is common when working with MutableList.

Domain-specific comparators

1. Chaining sortedBy and expecting true multi-key sorting

Broken idea:

val sorted = list.sortedBy { it.age }.sortedBy { it.name }

Why it is a problem:

• it does not clearly express primary and secondary keys
• it performs multiple sorts
• it is not the standard Kotlin solution for multi-field sorting

Use this instead:

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

2. Forgetting sortedBy returns a new list

list.sortedBy { it.age }
println(list) // original list is unchanged

Fix:

val sorted = list.sortedBy { it.age }

Or use sortBy / sortWith for mutable lists.

3. Mixing mutable and immutable APIs

• sortedBy, sortedWith -> return a new list

sortedBy vs sortedWith

Multi-field sorting in Kotlin

New sorted list

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

Equivalent compact form

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

Sort mutable list in place

people.sortWith(compareBy<Person> { it.age }.thenBy { it.name })

Descending + ascending

val sorted = list.sortedWith(
    compareByDescending<Person> { it.age }.thenBy { it.name }
)

Single-field sort

val sorted = list.sortedBy { it.age }

Remember

• sortedBy and sortedWith return a new list
• sortBy and sortWith modify a mutable list
• Use thenBy for secondary sorting
• Use compareBy to build multi-key comparators

How do I sort by multiple properties in Kotlin?

Use sortedWith together with compareBy and thenBy:

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

Can I chain sortedBy in Kotlin?

You can, but it is not the recommended way to express multi-field sorting. Use a comparator chain with compareBy(...).thenBy(...) instead.

What is the Kotlin equivalent of C# OrderBy().ThenBy()?

The closest equivalent is:

list.sortedWith(compareBy<Person> { it.age }.thenBy { it.name })

What is the difference between sortedWith and sortWith?

• sortedWith returns a new sorted list
• sortWith modifies a mutable list in place

How do I sort descending in Kotlin?

Use compareByDescending or reverse the comparator:

• Comparators — multi-field sorting in Kotlin is built on comparators.
• Collections in Kotlin — sorting is one of the most common collection operations.
• MutableList vs List — important because some sorting functions return a new list while others modify the original.
• Lambda expressions — sorting selectors like { it.age } and { it.name } are lambdas.
• Data classes — often used as the objects being sorted.
• Null safety — useful when sort fields may be nullable.
• Filtering and mapping — sorting is often combined with filter and map in collection pipelines.