Kotlin knowledge mapping: Evaluating map(), flatMap(), and flatten()

Whereas each the Android and iOS working techniques are inserting increasingly more weight on the modern practical programming patterns and paradigm launched by the trendy programming languages they make use of — i.e. Kotlin and Swift, respectively — the necessity to use and manipulate collections is rising exponentially with it.

The Kotlin Commonplace Library has included a sequence of extension features meant so as to add transformations into a group, and these features are additionally meant to deal with the rising want for good, fast, and environment friendly assortment manipulation.

There are 4 principal forms of assortment transformations as supplied by the Kotlin Commonplace Library: Map, Zip, Affiliate, and Flatten. For this text, I’ll consider solely two of those; i.e., Map and Flatten, as a result of this set of extension features has a particular affiliation and is eternally zipped collectively due to the same use instances they intention to arrange.

On this article, we’ll cowl:

Tracing the Map

Let’s begin with the fundamentals of Map. The transformation perform of map() is outlined by Kotlin’s official documentation:

The mapping transformation creates a group from the outcomes of a perform on the weather of one other assortment. It applies the given lambda perform to every subsequent aspect and returns the listing of the lambda outcomes. The order of outcomes is similar as the unique order of parts.

To raised clarify what this implies, let’s begin off with a easy instance:

On this instance, we’ve a Set of three values: the numbers 1, 2, and three, that are then processed utilizing a map() perform with a predicate that multiplies every one of many parts from the numbers assortment by 5, and returns the ensuing listing of:

[5, 10, 15]

The map() perform has a counterpart perform that will leverage the aspect’s index extra conveniently. Specifically, mapIndexed(), is ideal to make use of when the index of a component could also be wanted within the desired transformation.

Right here’s a easy instance utilizing the identical fundamental Set assortment from earlier than, adopted by its consequence:

[1, 1, 1]

Following Kotlin’s null-safety initiative, each of those extension features additionally include variations of them that permit for the ensuing assortment to disregard all values that could be nullified by the given transformation.

Each mapNotNull() and mapIndexedNotNull() have been conveniently created, holding in thoughts that null values should lead to some instances, and their utilization is showcased within the subsequent code block:

[6, 3, 9]
[6, 3, 9]

Lastly, utilizing a Map transformation with a Map assortment opens up two parallel choices. Transformations that need to be utilized to the keys of the map ought to use the mapKeys() perform, whereas transformations utilized to the values of the map ought to as an alternative use the mapValues() perform.

Because the official documentation explains, each of those features use the transformations that take a map entry as an argument, so you may function each its key and worth:

{FIRST=1, SECOND=2, THIRD=3, FOURTH=4}
{first=6, second=8, third=8, fourth=10}

Flatten the land

Because the Kotlin documentation on assortment transformations explains, working with nested collections generally requires using the usual library features that present flat entry to nested assortment parts. There are two principal features that present these sorts of options: flatten() and flatMap(), each of that are thought-about a part of the Flatten assortment transformation features group.

First there’s flatten(), a perform that can soak up a group of collections and return a singular Listing containing the entire parts that the nested collections used to have.

On this first instance for flatten(), we take a nested listing of Sets, and we’ll flatten them right into a single Listing that can merely present all of the values:

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

The flatten() perform is able to flattening nested collections containing any form of object sorts. To additional show that, right here’s a really related instance that makes use of String as an alternative:

[Los Angeles, San Francisco, Sacramento, Ausitn, San Antonio, Houston, Dallas, Mexico City, Monterrey, Guadalajara]

Moreover, this perform shouldn’t be restricted by the item kind within its nested collections. Because of this the inside collections can comprise completely different object sorts within it, and the flatten() perform ought to nonetheless be capable of assemble a ensuing Listing of kind Any that can comprise the entire outcomes of assorted sorts:

[1, 2, 3, one, two, three, 1.0, 2.0, 3.0]

Map the flat land

The opposite Flatten assortment transformation perform that Kotlin offers is flatMap(). As per its documentation, this second perform works very equally to flatten() however provides the extra flexibility of offering a solution to course of the nested collections by taking a perform that maps a group aspect to a different assortment. Due to this, flatMap() returns a single listing of its return values on all the weather.

flatMap() behaves as a subsequent name of map() — with a group as a mapping consequence — and flatten().
— kotlinlang.org

Let’s begin with an instance we used to checkflatten(), however add some variation to it with a view to emphasize the distinction between each these choices:

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Within the instance above, we’ve recycled one of many flatten() examples, however as an alternative we’re utilizing the flatMap() perform to reach on the identical consequence.

Because it’s seen right here, the flatMap() perform not solely flattens the nested assortment, however will get an extra oportunity so as to add a metamorphosis to the within assortment kind — on this case the completely different Sets — by the map() perform that will get triggered on the inside assortment for additional manipulation:

[6, 7, 8, 9, 4, 5, 1, 2, 3, 0]

On this second flatMap() instance, we’re but once more taking the identical code, however this time we’re including an additional manipulation as a part of the map() perform step, with a view to additional expose the principle variations between each of the Flatten features.

The flatMap() perform is very helpful when coping with complicated knowledge courses or POJOs, as it’ll make it possible to seek out or additional remodel the knowledge that’s nested beneath the primary layer.

Within the instance beneath, we’ll use a mildly complicated knowledge class to discover extra difficult knowledge manipulations within a flatMap() name:

[Austin, San Antonio, Dallas, Houston, Los Angeles, San Francisco, Sacramento, Monterrey, Guadalajara, Mexico City]

And simply as its flatten() compatriot does, the flatMap() perform can also be able to flattening collections of various sorts, which find yourself being interpreted as collections of kind Any:

[one, two, three, 1, 2, 3]

Lastly, the flatMap() perform can also be able to including an extra map() transformation within its transformation block with a view to add much more transformations to the gathering on the innermost layers of the nested assortment teams:

[Austin:Texas, San Antonio:Texas, Dallas:Texas, Houston:Texas, Los Angeles:California, San Francisco:California, Sacramento:California, Monterrey:Mexico, Guadalajara:Mexico, Mexico City:Mexico]

This final instance exhibits the head utilization of the flatMap() perform. The mix of a flatMap() with a subsequent map() name will permit for probably the most versatile and granular manipulation of lists, whereas offering the consumer with a flat interpretation of such for any form of wants.

Conclusion

All three Kotlin knowledge mapping features — map(), flatten(), and flatMap() — are a part of a bunch of transformation features that particularly work with Kotlin collections. They support with the interpretation and manipulation of complicated and/or nested collections, that could be too laborious to investigate of their default state.

By leveraging any of those highly effective features accurately, builders ought to be capable of higher extract the knowledge wanted from any form of complicated assortment construction. This system is crucial in maximizing the effectivity and reliability that goes into the developer’s work. Appropriately utilizing these might are available further useful when coping with the all-so in style Reactive Streams coding paradigm that in style concurrency libraries like RxJava and Kotlin Coroutines allow you to do.