Kotlin Sequences vs Java Streams

If you don't have any clue about Kotlin sequences, you can refer to this post.

Sequences are similar to java streams. In fact when they were originally introduced in kotlin, they were called streams. We can dwell much in java streams.
The choice of when to use java streams or kotlin sequences depends on the platform

• Java streams were introduced in Java 8, so if you’re running on a version of Java older than that, you need to use kotlin sequences instead.
• On Android, Java stream support began in Android 7.0, so if you’re targeting a minimum version of the OS below that, sequences are your option.
• If you’re developing a kotlin library, it’d be wise to stick with sequences and other pure kotlin concepts, because it enables your library to target multiple platforms.

Now having know the above let us dive into sample code snippets

Java Streams

Let us pick the computations below for example

    List finalList = List.of(
        List.of("myFirstName", "mySecondName", "myThirdName", "myOtherName", "", ""),
        List.of("abFirstName", "abFirstName", "abThirdName", "abOtherName", "", ""));
    List returnList = Collections.singletonList(finalList.stream()
        .filter(item -> !item.toString().isEmpty())
        .flatMap(item -> item.toString())
        .sorted().map(itemList -> itemList.toString().toUpperCase()));

The above sample code snippet to demonstrates several operations in java streams which are sequential in nature. However, since we have multiprocessing, java changed the game by introduction of parallel streams.

Java Parallel Streams

Java streams huge advantage over Kotlin sequences is that streams can be run in parallel. Sequences do not run in parallel - after all, they are sequential by definition!
Running your operation chains in parallel comes with a startup cost, but once you overcome that cost, it’s generally hard to beat their performance in many cases.

Parallel streams enable us to execute code in parallel on separate cores. The final result is the combination of each individual outcome.So if you’re on the JVM and you’re processing lots of data with an operation chain that’s amenable to running in parallel, it’d be worth considering Java’s parallel streams.
Assume the example below to demonstrate it. To run java streams in parallel, you just need to add parallel() or using parallelStream() on a Collection before performing list of operations

Example 1

 IntStream rangeofInts = IntStream.rangeClosed(1, 10);
        rangeofInts.parallel().forEach(System.out::println);

Example 2

  List returnList = Collections.singletonList(finalList.parallelStream()
        .filter(item -> !item.toString().isEmpty())
        .flatMap(item -> item.toString())
        .sorted().map(itemList -> itemList.toString().toUpperCase()));

Performance Implications

Parallelism can bring performance benefits in certain use cases. But parallel streams cannot be considered as a magical performance booster. So, sequential streams should still be used as default during development.

In conclusion,although sequences can perform much better than collections, there are still plenty of cases where collections get the edge.