Why sequences matter for performance in Kotlin - See It in Action

Why sequences matter for performance

📖 Scenario: You are working with a list of numbers and want to perform multiple operations on them. You want to understand how using sequences can improve performance by processing elements lazily, instead of creating intermediate collections.

🎯 Goal: Build a Kotlin program that compares processing a list with normal collection operations versus using sequences, to see how sequences can improve performance.

📋 What You'll Learn

Create a list of integers from 1 to 1,000,000

Create a variable to hold a threshold value of 1000

Use normal collection operations to filter numbers greater than the threshold and map them by multiplying by 2

Use sequence operations to do the same filtering and mapping

Print the size of the resulting lists from both methods

💡 Why This Matters

🌍 Real World

Sequences help when working with large data sets or chains of operations, making programs faster and using less memory.

💼 Career

Understanding sequences is important for Kotlin developers to write efficient and performant code, especially in data processing and backend applications.

1

Create the list of numbers

Create a list called numbers containing integers from 1 to 1_000_000 using (1..1_000_000).toList().

Kotlin

# Create the list of numbers
# Your code here

Hint

Use Kotlin's range and toList() to create the list.

2

Set the threshold value

Create an integer variable called threshold and set it to 1000.

Kotlin

val numbers = (1..1_000_000).toList()
# Create the threshold variable
# Your code here

Hint

Just create a simple integer variable.

3

Filter and map using collections and sequences

Create a list called filteredMappedList by filtering numbers for values greater than threshold and then mapping each value to its double using normal collection operations. Then create a sequence called filteredMappedSequence by converting numbers to a sequence, applying the same filter and map operations.

Kotlin

val numbers = (1..1_000_000).toList()
val threshold = 1000
# Create filteredMappedList using filter and map on numbers
# Create filteredMappedSequence using asSequence(), filter, and map
# Your code here

Hint

Use filter and map on the list and on the sequence.

4

Print the sizes of the results

Print the size of filteredMappedList and the size of filteredMappedSequence converted to a list using toList(). Use println for both.

Kotlin

val numbers = (1..1_000_000).toList()
val threshold = 1000

val filteredMappedList = numbers.filter { it > threshold }.map { it * 2 }
val filteredMappedSequence = numbers.asSequence().filter { it > threshold }.map { it * 2 }
# Print the size of filteredMappedList
# Print the size of filteredMappedSequence converted to list
# Your code here

Hint

Use println(filteredMappedList.size) and println(filteredMappedSequence.toList().size).

Practice

1. What is the main advantage of using Sequence in Kotlin compared to a regular List?

easy

A. It processes elements lazily, improving performance with large data.

B. It stores elements in a database automatically.

C. It converts all elements to strings immediately.

D. It requires less code to create than a list.

Solution

1. Step 1: Understand how sequences process data

   Sequences process elements one by one only when needed, not all at once.

2. Step 2: Compare with lists

   Lists process all elements eagerly, which can be slower and use more memory for large data.

3. Final Answer:

   It processes elements lazily, improving performance with large data. -> Option A

4. Quick Check:

   Lazy processing = better performance [OK]

Hint: Sequences process lazily, lists process eagerly [OK]

Common Mistakes:

• Thinking sequences store data in a database
• Confusing lazy processing with immediate conversion
• Assuming sequences need less code to create

2. Which of the following is the correct way to create a sequence from a list in Kotlin?

easy

A. val seq = list.toSequence()

B. val seq = list.asSequence()

C. val seq = Sequence(list)

D. val seq = list.sequence()

Solution

1. Step 1: Recall Kotlin sequence creation syntax

   The standard way to create a sequence from a list is using asSequence().

2. Step 2: Check each option

   val seq = list.asSequence() uses list.asSequence(), which is correct. Others are invalid or do not exist.

3. Final Answer:

   val seq = list.asSequence() -> Option B

4. Quick Check:

   Use asSequence() to convert list to sequence [OK]

Hint: Use asSequence() to convert list to sequence [OK]

Common Mistakes:

• Using toSequence() which does not exist
• Trying to call sequence() on list
• Trying to instantiate Sequence directly

3. What will be the output of this Kotlin code?

val list = listOf(1, 2, 3, 4, 5)
val result = list.asSequence()
    .map { println("Mapping $it"); it * 2 }
    .filter { println("Filtering $it"); it > 5 }
    .toList()
println(result)

medium

A. Mapping and filtering printed step-by-step, then [6, 8, 10]

B. No output except [6, 8, 10]

C. [6, 8, 10] with all mapping and filtering printed before the list

D. Compilation error due to println inside lambda

Solution

1. Step 1: Understand lazy evaluation of sequences

   Sequences process elements one by one, so map and filter print statements happen step-by-step per element.

2. Step 2: Trace the output

   For each element, "Mapping" prints, then "Filtering" prints, then next element. Finally, the filtered list [6, 8, 10] prints.

3. Final Answer:

   Mapping and filtering printed step-by-step, then [6, 8, 10] -> Option A

4. Quick Check:

   Lazy = step-by-step prints [OK]

Hint: Sequences print lazily per element, not all at once [OK]

Common Mistakes:

• Assuming all map prints happen before filter prints
• Expecting no prints due to lazy evaluation
• Thinking println causes compile error

4. Identify the problem in this Kotlin code that tries to improve performance using sequences:

val numbers = (1..5).toList()
val doubled = numbers.map { it * 2 }
val filtered = doubled.asSequence().filter { it > 5 }.toList()
println(filtered)

medium

A. toList() is missing after map, causing error.

B. Filter is applied before map, causing wrong results.

C. Sequence is created after map, so map is eager and wastes memory.

D. Sequence cannot be created from a list.

Solution

1. Step 1: Analyze the order of operations

   Mapping happens first on the list eagerly, then sequence is created only for filtering.

2. Step 2: Understand performance impact

   Because map is eager, it processes all elements immediately, losing sequence benefits.

3. Final Answer:

   Sequence is created after map, so map is eager and wastes memory. -> Option C

4. Quick Check:

   Sequence after map loses lazy benefits [OK]

Hint: Create sequence before map to keep lazy processing [OK]

Common Mistakes:

• Thinking filter order is wrong
• Expecting error due to missing toList() after map
• Believing sequence can't be made from list

5. You have a large list of numbers and want to find the sum of squares of even numbers greater than 10. Which Kotlin code snippet uses sequences best for performance?

hard

A. val sum = numbers.filter { it > 10 }
.filter { it % 2 == 0 }
.map { it * it }
.sum()

B. val sum = numbers.asSequence()
.map { it * it }
.filter { it > 10 && it % 2 == 0 }
.sum()

C. val sum = numbers.map { it * it }
.filter { it > 10 && it % 2 == 0 }
.sum()

D. val sum = numbers.asSequence()
.filter { it > 10 }
.filter { it % 2 == 0 }
.map { it * it }
.sum()

Solution

1. Step 1: Identify the correct order for filtering and mapping

   Filter first for numbers > 10 and even, then map to square to avoid unnecessary calculations.

2. Step 2: Use sequence to process lazily

   Using asSequence() before filters and map ensures lazy evaluation and better performance on large lists.

3. Final Answer:

   val sum = numbers.asSequence() .filter { it > 10 } .filter { it % 2 == 0 } .map { it * it } .sum() -> Option D

4. Quick Check:

   Sequence + filter before map = best performance [OK]

Hint: Filter before map, use sequence for lazy processing [OK]

Common Mistakes:

• Mapping before filtering wastes work
• Not using sequence loses lazy benefits
• Combining filters incorrectly after map