Java streams vs Kotlin sequences - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Java Stream vs Kotlin Sequence Lazy Evaluation

Consider the following Kotlin code using a Sequence and a Java Stream. What will be the output?

Kotlin

val list = listOf(1, 2, 3, 4)

val seq = list.asSequence()
    .map {
        println("Sequence map: $it")
        it * 2
    }
    .filter {
        println("Sequence filter: $it")
        it > 4
    }

println("Sequence result: ${seq.toList()}")

A

Sequence map: 1
Sequence map: 2
Sequence map: 3
Sequence map: 4
Sequence filter: 2
Sequence filter: 4
Sequence filter: 6
Sequence filter: 8
Sequence result: [6, 8]

B

Sequence map: 1
Sequence filter: 2
Sequence map: 2
Sequence filter: 4
Sequence map: 3
Sequence filter: 6
Sequence result: [6]

C

Sequence map: 1
Sequence filter: 2
Sequence map: 2
Sequence filter: 4
Sequence map: 3
Sequence filter: 6
Sequence map: 4
Sequence filter: 8
Sequence result: [6, 8]

D

Sequence map: 1
Sequence filter: 2
Sequence map: 2
Sequence filter: 4
Sequence map: 3
Sequence filter: 6
Sequence map: 4
Sequence filter: 8
Sequence result: [2, 4, 6, 8]

💡 Hint

Remember that Kotlin Sequence operations are lazy and process elements one by one.

Kotlin Sequence processes elements lazily, so map and filter are called per element in order. The output shows the interleaved calls for each element before moving to the next.

🧠 Conceptual

intermediate

Difference in Evaluation Strategy Between Java Streams and Kotlin Sequences

Which statement best describes the difference between Java Streams and Kotlin Sequences?

A Kotlin Sequences process elements lazily one by one, while Java Streams may process elements in batches or eagerly depending on the terminal operation.

B Both Java Streams and Kotlin Sequences process elements eagerly by default.

C Java Streams are always lazy, while Kotlin Sequences are always eager.

D Java Streams process elements one by one lazily, but Kotlin Sequences process all elements eagerly before any operation.

💡 Hint

Think about how each handles intermediate operations and when elements are processed.

Kotlin Sequences are lazy and process elements one by one through the chain of operations. Java Streams are also lazy but may internally optimize processing in batches depending on the terminal operation.

🔧 Debug

advanced

Why Does This Kotlin Sequence Code Not Print Anything?

Look at this Kotlin code using a Sequence. Why does it not print anything?

Kotlin

val seq = sequenceOf(1, 2, 3)
    .map {
        println("Mapping $it")
        it * 2
    }

// No terminal operation here

A Because <code>map</code> is executed immediately but the output is buffered and not printed.

B Because <code>println</code> inside <code>map</code> is ignored in sequences.

C Because <code>sequenceOf</code> creates an empty sequence by default.

D Because <code>map</code> is not called until a terminal operation is invoked on the sequence.

💡 Hint

Think about when lazy operations run in Kotlin Sequences.

Kotlin Sequences are lazy. Intermediate operations like map do not run until a terminal operation (like toList()) is called.

📝 Syntax

advanced

Identify the Syntax Error in Java Stream Code

Which option contains a syntax error in this Java Stream code snippet?

Kotlin

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

var result = numbers.stream()
    .map(n -> n * 2)
    .filter(n -> n > 4)
    .collect(Collectors.toList());

A

var result = numbers.stream()
    .map(n -> n * 2)
    .filter(n -> n > 4)
    .collect(Collectors.toList

B

var result = numbers.stream()
    .map(n -> n * 2)
    .filter(n -> n > 4)
    .collect(Collectors.toList());

C

;))(tsiLot.srotcelloC(tcelloc.    
)4 > n >- n(retlif.    
)2 * n >- n(pam.    
)(maerts.srebmun = tluser rav

D

ar result = numbers.stream()
    .map(n -> n * 2)
    .filter(n -> n > 4)
    .collect(Collectors.toList());

💡 Hint

Look carefully at the parentheses and method calls.

Option A is missing the closing parenthesis after toList, causing a syntax error.

🚀 Application

expert

Choosing Between Java Streams and Kotlin Sequences for Large Data Processing

You need to process a very large list of data with multiple transformations and filters. Which approach is best to minimize memory usage and why?

A Use Java Streams because they always process elements eagerly, which is faster for large data.

B Use Kotlin Sequences because they process elements lazily one by one, reducing memory overhead.

C Use Kotlin Sequences because they convert the entire list to a new list before processing, improving speed.

D Use Java Streams because they store all intermediate results in memory, which reduces CPU usage.

💡 Hint

Think about lazy processing and memory consumption.

Kotlin Sequences process elements lazily and one at a time, which helps keep memory usage low when handling large data sets. Java Streams can also be lazy but may have different internal optimizations.