Is there a reason why there are multiple ways to do the same thing in Kotlin

val viaSequence = items.asSequence()
    .filter { it%2 == 0 }
    .map { it*2 }
    .toList()
println(viaSequence)

val viaIterable = items.asIterable()
    .filter { it%2 == 0 }
    .map { it*2 }
    .toList()
println(viaIterable)

val viaStream = items.stream()
    .filter { it%2 == 0 }
    .map { it*2 }
    .toList()
println(viaStream)

I know that the following code creates a list on every step, which adds load to the GC, and as such should be avoided:

items.filter { it%2 == 0 }.map { it*2 }

CodePudding user response：

One of your three variants is the same as using the List itself:

items.asIterable()
    .filter { it%2 == 0 }

Here, you're calling the exact same filter function as if you just called items.filter. The List itself is an Iterable so it's the Iterable filter that is called. This filter looks at all available elements and returns a complete list.

So the question is why we have both streams and sequences.

Streams are part of Java. Many of the terminal operations produce Optional. Other operations, such as toList(), will produce non-null-safe platform types such as List<Integer!>. On the other hand, sequences are native to Kotlin, and they can be used with Kotlin's own compile-time null-safety features. Also, sequences are available in non-JVM variants of Kotlin.

The Kotlin designers probably had to create a new class, because if they had just added new operations to Stream, e.g. as extension functions, they would clash with existing names (e.g. max() returns Optional in Java, and that's not ideal for Kotlin, but choosing a name other than the natural name max wouldn't be ideal either.)

So in most cases you should prefer sequences as they are more Kotlin-idiomatic. However, there are some things Java Streams can do that aren't yet available to sequences (for example, SummaryStatistics, or parallel operations). When you need an operation that is only available in Streams, but you have a Sequence, you can convert the Sequence to a Stream using asStream() (as well as vice versa).

Another advantage of Streams is that you can use primitive streams such as IntStream, to avoid unnecessary boxing/unboxing.

CodePudding user response：

Streams come from Java, where there are no inline functions, so Streams are the only way to use these functional chains on a collection in Java. Kotlin can do them directly on Iterables, which is better for performance in many cases because intermediate Stream objects don't need to be created.

Kotlin has Sequences as an alternative to Streams with these advantages:

• They work back to Java 1.6. Streams require Java 8 or higher.
• They use null to represent missing items instead of Optional. Nullable values are easier to work with in Kotlin because of its null safety features. It's also better for performance to avoid wrapping all the items in the collection.
• Some of the operators and aggregation functions are much more concise and avoid having to juggle generic types (compare Sequence.groupBy to Stream.collect).
• There are more operators provided for Sequences, which result in performance advantages and simpler code by cutting out intermediate steps.
• Many terminal operators are inline functions, so they omit the last wrapper that a Stream would need.
• The sequence builder lets you create a complicated lazy sequence of items with simple sequential syntax in a coroutine. Very powerful.

The other answer mentions the advantages that Streams have.

Nice article comparing them here.