Java streams vs Kotlin sequences

Introduction

Java streams and Kotlin sequences help process collections of data step-by-step without writing loops. They make code cleaner and easier to read.

When you want to process a list of items like filtering or transforming them.

When you want to avoid writing long loops and nested conditions.

When you want to handle large data efficiently without creating many intermediate collections.

When you want to chain multiple operations on data in a clear way.

When you want lazy evaluation to improve performance.

Syntax

Kotlin

Java Stream example:
List<String> names = List.of("Anna", "Bob", "Cathy");
names.stream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase)
    .forEach(System.out::println);

Kotlin Sequence example:
val names = listOf("Anna", "Bob", "Cathy")
names.asSequence()
    .filter { it.startsWith("A") }
    .map { it.uppercase() }
    .forEach { println(it) }

Java streams use stream() to start processing collections.

Kotlin sequences use asSequence() to enable lazy operations.

Examples

This filters even numbers and doubles them, then collects results back to a list.

Kotlin

val numbers = listOf(1, 2, 3, 4, 5)

// Kotlin sequence example
val result = numbers.asSequence()
    .filter { it % 2 == 0 }
    .map { it * 2 }
    .toList()

println(result)

Java stream does the same: filters even numbers, doubles them, and collects to a list.

Kotlin

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

// Java stream example
List<Integer> result = numbers.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * 2)
    .toList();

System.out.println(result);

Shows that mapping happens only when toList() is called, demonstrating lazy evaluation.

Kotlin

val names = listOf("Anna", "Bob", "Cathy")

// Kotlin sequence lazy evaluation
val seq = names.asSequence()
    .map {
        println("Mapping $it")
        it.uppercase()
    }

println("Before terminal operation")
seq.toList()

Java streams also evaluate lazily, mapping runs only when terminal operation toList() is called.

Kotlin

List<String> names = List.of("Anna", "Bob", "Cathy");

// Java stream lazy evaluation
Stream<String> stream = names.stream()
    .map(name -> {
        System.out.println("Mapping " + name);
        return name.toUpperCase();
    });

System.out.println("Before terminal operation");
stream.toList();

Sample Program

This program filters names starting with 'A' and converts them to uppercase using Kotlin sequences and Java streams (simulated in Kotlin). Both produce the same result.

Kotlin

fun main() {
    val names = listOf("Anna", "Bob", "Cathy", "Alex")

    println("Kotlin Sequence Result:")
    val kotlinResult = names.asSequence()
        .filter { it.startsWith("A") }
        .map { it.uppercase() }
        .toList()
    println(kotlinResult)

    println("Java Stream Result:")
    // Simulating Java stream in Kotlin for demonstration
    val javaResult = names.stream()
        .filter { it.startsWith("A") }
        .map { it.uppercase() }
        .toList()
    println(javaResult)
}

Important Notes

Both Java streams and Kotlin sequences support lazy evaluation, meaning operations run only when needed.

Kotlin sequences are similar to Java streams but integrate more naturally with Kotlin collections.

Use sequences or streams when working with large data to improve performance by avoiding unnecessary intermediate collections.

Summary

Java streams and Kotlin sequences help process collections step-by-step in a readable way.

Both support lazy evaluation to improve performance.

Kotlin sequences fit naturally with Kotlin code, while Java streams are standard in Java.

Practice

1. Which statement best describes the main similarity between Java streams and Kotlin sequences?

easy

A. Both provide lazy evaluation to process collections efficiently.

B. Both are eager and process all elements immediately.

C. Both are only available in Kotlin.

D. Both require manual iteration over collections.

Solution

1. Step 1: Understand lazy evaluation concept

   Lazy evaluation means processing elements only when needed, not all at once.

2. Step 2: Compare Java streams and Kotlin sequences

   Both Java streams and Kotlin sequences use lazy evaluation to improve performance when processing collections.

3. Final Answer:

   Both provide lazy evaluation to process collections efficiently. -> Option A

4. Quick Check:

   Lazy evaluation = Both streams and sequences [OK]

Hint: Remember: streams and sequences delay processing until needed [OK]

Common Mistakes:

• Thinking both are eager by default
• Assuming Kotlin sequences are only in Java
• Believing manual iteration is required

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

easy

A. val seq = list.stream()

B. val seq = list.toStream()

C. val seq = Sequence(list)

D. val seq = list.asSequence()

Solution

1. Step 1: Recall Kotlin sequence creation syntax

   In Kotlin, you convert a collection to a sequence using the asSequence() extension function.

2. Step 2: Check each option

   val seq = list.stream() uses Java stream syntax, val seq = Sequence(list) is invalid constructor usage, val seq = list.toStream() is not a Kotlin function.

3. Final Answer:

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

4. Quick Check:

   Use asSequence() to get Kotlin sequence [OK]

Hint: Use asSequence() to convert collections in Kotlin [OK]

Common Mistakes:

• Using Java stream() method in Kotlin
• Trying to instantiate Sequence directly
• Using non-existent toStream() method

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

val list = listOf(1, 2, 3, 4)
val result = list.asSequence()
    .filter { it % 2 == 0 }
    .map { it * 2 }
    .toList()
println(result)

medium

A. [4, 8]

B. [1, 2, 3, 4]

C. [1, 3]

D. [2, 4, 6, 8]

Solution

1. Step 1: Apply filter to keep even numbers

   Filter keeps elements where it % 2 == 0, so from [1,2,3,4] we get [2,4].

2. Step 2: Map each filtered element by multiplying by 2

   Mapping [2,4] with it * 2 gives [4,8].

3. Final Answer:

   [4, 8] -> Option A

4. Quick Check:

   Filter evens then double = [4, 8] [OK]

Hint: Filter first, then map for correct sequence output [OK]

Common Mistakes:

• Mapping before filtering
• Confusing filter condition
• Expecting original list output

4. Identify the error in this Kotlin code using sequences:

val numbers = listOf(1, 2, 3)
val seq = numbers.asSequence()
val result = seq.filter { it > 1 }
println(result)

medium

A. Filter condition syntax is invalid.

B. Incorrect use of asSequence() on a list.

C. Missing terminal operation to trigger sequence evaluation.

D. Cannot print a sequence directly.

Solution

1. Step 1: Understand sequence evaluation

   Kotlin sequences are lazy and require a terminal operation like toList() to execute.

2. Step 2: Check code for terminal operation

   The code filters but does not collect or convert the sequence, so result is still a sequence, not a list.

3. Final Answer:

   Missing terminal operation to trigger sequence evaluation. -> Option C

4. Quick Check:

   Sequences need terminal operation to run [OK]

Hint: Always end sequences with terminal operation like toList() [OK]

Common Mistakes:

• Assuming filter runs immediately
• Trying to print sequence without conversion
• Confusing asSequence() usage

5. You want to process a large list of numbers in Kotlin, doubling only the odd numbers, but you want to avoid processing the entire list eagerly. Which approach is best?

1) Use list.map { if (it % 2 != 0) it * 2 else it }
2) Use list.asSequence().filter { it % 2 != 0 }.map { it * 2 }.toList()
3) Use list.stream().filter { it % 2 != 0 }.map { it * 2 }.collect(Collectors.toList())
4) Use list.asSequence().map { if (it % 2 != 0) it * 2 else it }.toList()

hard

A. Option 1 because map is simple and eager.

B. Option 2 because sequences filter and map lazily, processing only needed elements.

C. Option 3 because Java streams are faster in Kotlin.

D. Option 4 because it maps lazily but does not filter.

Solution

1. Step 1: Understand lazy processing need

   To avoid eager processing of the entire list, lazy evaluation is needed.

2. Step 2: Analyze each option's behavior

   Option 1 is eager map, processes all elements. Option 2 uses Kotlin sequences with filter and map lazily, then collects. Option 3 uses Java streams but in Kotlin context, less idiomatic. Option 4 maps lazily but does not filter, so processes all elements (conditionally doubling only odds).

3. Step 3: Choose best approach

   Option 2 best fits lazy processing of only odd numbers, avoiding unnecessary work.

4. Final Answer:

   Option 2 because sequences filter and map lazily, processing only needed elements. -> Option B

5. Quick Check:

   Lazy filter + map with sequences = Option 2 [OK]

Hint: Use sequences with filter then map for lazy selective processing [OK]

Common Mistakes:

• Using eager map on entire list
• Ignoring lazy evaluation benefits
• Confusing Java streams with Kotlin sequences