Sorted and sortedBy in Kotlin

Introduction

We use sorted and sortedBy to arrange items in a list in order. This helps us find things faster or show them nicely.

When you want to show a list of names in alphabetical order.

When you need to organize numbers from smallest to largest.

When you want to sort objects by one of their properties, like sorting people by age.

When you want to prepare data for reports or display in a neat order.

Syntax

Kotlin

val sortedList = list.sorted()
val sortedByList = list.sortedBy { item -> item.property }

sorted() works on lists of items that can be compared directly, like numbers or strings.

sortedBy { } lets you choose a property or value to sort by, useful for objects.

Examples

This sorts numbers from smallest to largest.

Kotlin

val numbers = listOf(3, 1, 4, 2)
val sortedNumbers = numbers.sorted()

This sorts strings alphabetically.

Kotlin

val names = listOf("Bob", "Alice", "Eve")
val sortedNames = names.sorted()

This sorts a list of people by their age from youngest to oldest.

Kotlin

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

val people = listOf(
    Person("Bob", 30),
    Person("Alice", 25),
    Person("Eve", 35)
)

val sortedByAge = people.sortedBy { it.age }

Sample Program

This program shows how to sort numbers, names, and a list of people by age using sorted() and sortedBy.

Kotlin

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

fun main() {
    val numbers = listOf(5, 2, 9, 1)
    val sortedNumbers = numbers.sorted()
    println("Sorted numbers: $sortedNumbers")

    val names = listOf("Charlie", "Alice", "Bob")
    val sortedNames = names.sorted()
    println("Sorted names: $sortedNames")

    val people = listOf(
        Person("Dave", 40),
        Person("Carol", 22),
        Person("Eve", 30)
    )
    val sortedPeopleByAge = people.sortedBy { it.age }
    println("People sorted by age:")
    for (person in sortedPeopleByAge) {
        println("${person.name} - ${person.age}")
    }
}

Important Notes

sorted() returns a new list and does not change the original list.

You can also use sortedDescending() or sortedByDescending { } to sort in reverse order.

Summary

sorted() arranges items in natural order (numbers or strings).

sortedBy { } arranges items by a chosen property.

Both create new sorted lists without changing the original.

Practice

1. What does the sorted() function do in Kotlin?

easy

A. It sorts the original list in place and returns nothing.

B. It arranges elements randomly in a new list.

C. It returns a new list with elements arranged in natural ascending order.

D. It filters elements based on a condition.

Solution

1. Step 1: Understand the purpose of sorted()

   The sorted() function creates a new list where elements are arranged in natural ascending order (numbers from smallest to largest, strings alphabetically).

2. Step 2: Check if original list changes

   The original list remains unchanged because sorted() returns a new sorted list without modifying the original.

3. Final Answer:

   It returns a new list with elements arranged in natural ascending order. -> Option C

4. Quick Check:

   sorted() = new ascending list [OK]

Hint: sorted() always returns a new ascending list [OK]

Common Mistakes:

• Thinking sorted() changes the original list
• Confusing sorted() with filtering
• Assuming sorted() arranges elements randomly

2. Which of the following is the correct syntax to sort a list of strings by their length using sortedBy in Kotlin?

easy

A. list.sortedBy { it.length }

B. list.sortedBy.length()

C. list.sortedBy(it.length)

D. list.sortedBy { length(it) }

Solution

1. Step 1: Identify correct lambda syntax for sortedBy

   The sortedBy function takes a lambda expression that returns the property to sort by. The correct syntax is list.sortedBy { it.property }.

2. Step 2: Check each option

   list.sortedBy { it.length } uses { it.length } which correctly accesses the length property of each string. Other options have syntax errors or incorrect usage.

3. Final Answer:

   list.sortedBy { it.length } -> Option A

4. Quick Check:

   sortedBy uses lambda with it.property [OK]

Hint: Use curly braces and 'it' to access property in sortedBy [OK]

Common Mistakes:

• Using parentheses instead of curly braces
• Calling length() as a function incorrectly
• Passing property outside lambda

3. What is the output of the following Kotlin code?

val numbers = listOf(5, 3, 8, 1)
val sortedNumbers = numbers.sortedBy { it % 3 }
println(sortedNumbers)

medium

A. [1, 3, 5, 8]

B. [3, 6, 9, 12]

C. [1, 5, 3, 8]

D. [3, 1, 5, 8]

Solution

1. Step 1: Calculate the sorting key for each element

   Calculate it % 3 for each number: 5 % 3 = 2, 3 % 3 = 0, 8 % 3 = 2, 1 % 3 = 1.

2. Step 2: Sort numbers by these keys

   Sort by keys in ascending order: 0 (3), 1 (1), 2 (5), 2 (8). So sorted list is [3, 1, 5, 8].

3. Final Answer:

   [3, 1, 5, 8] -> Option D

4. Quick Check:

   sortedBy { it % 3 } = [3, 1, 5, 8] [OK]

Hint: Calculate sorting key for each element before sorting [OK]

Common Mistakes:

• Sorting by values instead of keys
• Confusing modulo results
• Assuming sortedBy sorts original list

4. Identify the error in this Kotlin code snippet:

val fruits = listOf("apple", "banana", "cherry")
val sortedFruits = fruits.sortedBy(it.length)
println(sortedFruits)

medium

A. sortedBy cannot be used on lists of strings.

B. Missing curly braces around the lambda expression in sortedBy.

C. The list should be mutable to use sortedBy.

D. The println statement is incorrect.

Solution

1. Step 1: Check syntax of sortedBy usage

   The sortedBy function requires a lambda expression inside curly braces, like { it.length }. The code uses parentheses without braces, which is incorrect.

2. Step 2: Verify other options

   sortedBy works on lists of strings, the list can be immutable, and println is correct. So only the lambda syntax is wrong.

3. Final Answer:

   Missing curly braces around the lambda expression in sortedBy. -> Option B

4. Quick Check:

   sortedBy needs { } for lambda [OK]

Hint: Always use curly braces for lambda in sortedBy [OK]

Common Mistakes:

• Using parentheses instead of curly braces for lambda
• Thinking sortedBy needs mutable list
• Misunderstanding println usage

5. Given a list of data class objects data class Person(val name: String, val age: Int), how would you sort the list first by age ascending, then by name alphabetically using Kotlin's sorting functions?

hard

A. persons.sortedWith(compareBy({ it.age }, { it.name }))

B. persons.sortedBy { it.age + it.name }

C. persons.sortedBy { it.name }.sortedBy { it.age }

D. persons.sortedByDescending { it.age }.sortedBy { it.name }

Solution

1. Step 1: Understand multi-level sorting in Kotlin

   To sort by multiple properties, use sortedWith(compareBy(...)) passing lambdas for each property in priority order.

2. Step 2: Analyze options

   persons.sortedWith(compareBy({ it.age }, { it.name })) correctly uses compareBy with age first, then name. persons.sortedBy { it.age + it.name } incorrectly adds age and name (different types). persons.sortedBy { it.name }.sortedBy { it.age } sorts twice but second sort overrides first. persons.sortedByDescending { it.age }.sortedBy { it.name } sorts age descending, not ascending.

3. Final Answer:

   persons.sortedWith(compareBy({ it.age }, { it.name })) -> Option A

4. Quick Check:

   Use sortedWith(compareBy(...)) for multi-level sort [OK]

Hint: Use sortedWith(compareBy(...)) for sorting by multiple keys [OK]

Common Mistakes:

• Adding different types in sortedBy
• Chaining sortedBy loses previous sort
• Using sortedByDescending when ascending needed