DEV Community: SebaMutuku

Kotlin Sequences vs Java Streams

SebaMutuku — Sat, 18 Mar 2023 20:38:03 +0000

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.

Kotlin collections' chained functions optimization

SebaMutuku — Sat, 18 Mar 2023 19:20:38 +0000

Imagine having a collection of items that you would like to perform several operations like filter reduce, map, count etc on kotlin introduced apis to help the developer do this. Take below code snippet as an example.

 listOf(buildList { repeat(1000000) { add(Random.nextInt()) } }, buildList {
            repeat(181881) { add(Random.nextInt()) }
        }).flatten()
                .sortedDescending()
                .filter { it > 200 }.map { "Number: " to it }.forEach { println("Key : ${it.first} value ${it.second}") }

If you expect a large collection of items, with many operations think of how much memory it would consume. Now don't worry about that because kotlin also introduced type containers called Sequence<T> which come in handy when you want to optimise chained operations in collections. However you have to know when to apply it otherwise it might slow things down.
You will probably get more performance enhancement especially in cases where you’ve got:

many operations,
many elements,
the matching element appear toward the beginning.

Let us use sequences to code snippet above and see how it looks. To this we only need to add function asSequence and the code snippet changes to:

  listOf(buildList { repeat(1000000) { add(Random.nextInt()) } }, buildList {
            repeat(181881) { add(Random.nextInt()) }
        }).asSequence()
                .flatten()
                .sortedDescending()
                .filter { it > 200 }.map { "Number: " to it }.forEach { println("Key : ${it.first} value ${it.second}") }

Now having said that, there are several factors to consider. An example is when working with stateful and stateless operations

How sequences work and some expensive operations.

Sequences are based on iterators, and iterators can only step forward through its items, one item at a time. For example, when we call Sequence.toList(), the ArrayList is created with the default initial capacity. So, as more and more items are added to it, that underlying array will get replaced over and over until it’s large enough to hold all of the items.

The process of creating a new array and copying the elements can be expensive, and when it’s done enough times, it can really weigh down performance. So collecting the results of an operation chain into a resizable collection like ArrayList can be expensive for sequences, especially when it has many elements.

On the other hand, when you’re not collecting the results, sequences don’t take this penalty, so they’re more likely to outperform collections. This means that a terminal like forEach() is especially well-suited to sequences.

Stateless and Stateful Operations

Stateless operations are the ones where each element is operated on without any context or knowledge of the other elements present in the collection.

These operations are sandboxed and don’t care about other elements and their values.
The map operation is a good stateless operation.

On the other hand, stateful operations are the ones where each element is operated on with full context or knowledge of all the other elements.

These operations cannot do what they do, without having knowledge about all the other elements.
The distinct and sort operations are some good examples in this category. Below is a code snipped

val list = ourList
    .asSequence()
    .filter { it.value in OtherValueCheck }
    .sortedBy { it.toString() .startsWith("my") }                  
    .map { it.copy(label = "New!") }
    .toSet()

Although sorted() itself is an intermediate operation, it invokes a terminal operation - toMutableList(). This means, the above sequence converts it back into a collection. Any sequence that performs the above operations is said to be stateful and the other is termed to as stateless.

some similarities and differences between sequences and collections.

Both Sequence and Collection include an iterator() function, but Collection also includes some other properties and functions, such as size, isEmpty(), and contains().

Sequences are based on iterators, they handle first-to-last operations brilliantly. But there are some collection operations that are processed last-to-first, and many of those are not supported by sequences.

Sequences support:

fold()
reduce()
take()
drop()
However, they do not support :
foldRight()
reduceRight()
take()
takeLast()
dropLast().

This means if you want to perform the unsupported functions you might want to convert your list back to a collection or use collections
Other limitations include:

Slicing
Reversing

In conclusion, to know when to use sequences or collections, it is always good to weigh the balance between supported functions and operations, and performance and memory usage