Xantier - Kotlin Collection Extensions

Kotlin Collection Extensions Cheat Sheet
by Xantier via cheatography.com/38756/cs/12075/
Creating Collections
Arrays
Simple Array val intArray: Array<Int> = arrayOf(1, 2, 3)
Copy of Array val copyOfArray: Array<Int> = intArray.copyOf()
Partial copy of val partialCopyOfArray: Array<Int> = intArray.copyOfRange(0, 2)

Array
Lists
Simple List val intList: List<Int> = listOf(1, 2, 3) Or arrayListOf(1,2,3)
Empty List val emptyList: List<Int> = emptyList() Or listOf()
List with no null val listWithNonNullElements: List<Int> = same as List(1,3)

elements listOfNotNull(1, null, 3)
Sets
Simple Set val aSet: Set<Int> = setOf(1) Or hashSetOf(1) / linkedSerOf(1)
Empty Set val emptySet: Set<Int> = emptySet() Or setOf() / hashSetOf() / linkedSetOf()
Maps
Simple Map val aMap: Map<String, Int> = mapOf("hi" to 1, Or mapOf(Pair("hi", 1) / hashMapOf("hi" to 1) /

"hello" to 2) linkedMapOf("hi" to 1)
Empty Map val emptyMap: Map<String, Int> = emptyMap() Or mapOf() / hashMapOf() / linkedMapOf()
Black sheep, mutables
Simple Mutable val mutableList: MutableList<Int> = mutableListOf(1, 2, 3)

List
Simple Mutable val mutableSet: MutableSet<Int> = mutableSetOf(1)

Set
Simple Mutable var mutableMap: MutableMap<String, Int> = mutableMapOf("hi" to 1, "hello" to 2)

Map
We will be using these collections throughout the cheat sheet.
Operators
Method Example Result Explanation
Iterables
Plus intList + 1 [1, 2, 3, 1] Returns a new iterables with old values + added one
Plus (Iterable) intList + listOf(1, 2, 3) [1, 2, 3, 1, 2, 3] Return a new iterables with old values + values from added iterable
Minus intList - 1 [2, 3] Returns a new iterables with old values - subtracted one
By Xantier Published 14th June, 2017. Sponsored by CrosswordCheats.com

cheatography.com/xantier/ Last updated 14th June, 2017. Learn to solve cryptic crosswords!
Page 1 of 10. http://crosswordcheats.com
Operators (cont)
Minus (Iterable) intList - listOf(1, 2) `[3] Returns a new iterables with old values - values from
subtracted iterable
Maps
Plus aMap + Pair("Hi", 2) {hi=1, hello=2, Returns new map with old map values + new Pair. Updates
Goodbye=3} value if it differs
Plus (Map) aMap + mapOf(Pair("hello", 2), {hi=1, hello=2, Returns new map with old map values + Pairs from added
Pair("Goodbye", 3) Goodbye=3} map. Updates values if they differ.
Minus aMap - Pair("Hi", 2) {Hi=2} Takes in a key and removes if found
Minus (Map) aMap - listOf("hello", "hi") {} Takes in an iterable of keys and removes if found
Mutables
Minus Assign mutableList -= 2 [1, 3] Mutates the list, removes element if found. Returns boolean
Plus Assign mutableList += 2 [1, 3, 2] Mutates the list, adds element. Returns boolean
Minus Assign mutableMap.minusAssign("hello") {hi=1} Takes in key and removes if that is found from the mutated
(MutableMap) map. Returns boolean. Same as -=
Plus Assign mutableMap.plusAssign("Goodbye" {hi=1, Goodbye=3} Takes in key and adds a new pair into the mutated map.
(MutableMap) to 3) Returns boolean. Same as +=
Transformers
Associate intList.associate { {1=1, 2=2, Returns a Map containing key-value pairs created by lambda
Pair(it.toString(), it) } 3=3}
Map intList.map { it + 1 } [2,3,4] Returns a new list by transforming all elements from the initial
Iterable.
MapNotNull intList.mapNotNull { null } [] Returned list contains only elements that return as not null from
the lamdba

Transformers (cont)
MapIndexed intList.mapIndexed { idx, [2,4,5] Returns a new list by transforming all elements from the initial Iterable.
value -> Lambda receives an index as first value, element itself as second.
if (idx == 0) value + 1
else value + 2 }
MapIndexed intList.mapIndexedNotNull [4,5] Combination of Map, MapIndexed & MapIndexedNotNull

NotNull { idx, value ->
if (idx == 0) null
else value + 2 }
MapKeys aMap.mapKeys { pair -> {hi, mate=1, Transforms all elements from a map. Receives a Pair to lambda, lamdba
pair.key + ", mate" } hello, mate=2} return value is the new key of original value
MapValues aMap.mapValues { pair -> {hi=3, hello=4} Transforms all elements from a map. Receives a Pair to lambda, lamdba
pair.value + 2 }) return value is the new value for the original key.
Reversed intList.reversed()) [3,2,1]
Partition intList.partition { it > Pair([1,2], Splits collection into to based on predicate

2 }) [3])
Slice intList.slice(1..2)) [2,3] Takes a range from collection based on indexes
Sorted intList.sorted()) [1,2,3]
SortedByDe intList.sortedByDescendin [3,2,1] Sorts descending based on what lambda returns. Lamdba receives the value
scending g { it } itself.
SortedWith intList.sortedWith(Compar [3,1,2] Takes in a Comparator and uses that to sort elements in Iterable.
ator<Int> { x, y ->
when {
x == 2 -> 1
y == 2 -> -1
else -> y - x
}
})

Transformers (cont)
Flatten listOf(intList, [2,3,4,1] Takes elements of all passed in collections and returns a collection with all
aSet).flatten() those elements
FlatMap listOf(intList, [2,3,4,1] Used for Iterable of Iterables and Lambdas that return Iterables. Transforms
with just aSet).flatMap { it } elements and flattens them after transformation.
return
FlatMap listOf(intList, [2,3,4,2] FlatMap is often used with monadic containers to fluently handle context, errors
with aSet).flatMap { iterable: and side effects.
transform
Iterable<Int> ->
iterable.map { it + 1 }
}
Zip listOf(3, 4).zip(intList) [(3,1), Creates a list of Pairs from two Iterables. As many pairs as values in shorter of
(4,2)] the original Iterables.
Zip with listOf(3, 4).zip(intList) { [(1,3), Creates a list of Pairs from two Iterables. As many pairs as values in shorter of
predicate firstElem, secondElem -> (2,4)] the original Iterables. Lambda receives both items on that index from Iterables.
Pair(firstElem - 2,
secondElem + 2)
}
Unzip listOf(Pair("hi", 1), Pair([hi, Reverses the operation from zip. Takes in an Iterable of Pairs and returns them
Pair("hello", 2)).unzip() hello], as a Pair of Lists.
[1,2])
Aggregators
Folds And Reduces
Fold intList.fold(10) { accumulator, 16 Accumulates values starting with initial and applying operation from left to right.
value -> (10+1+2 Lambda receives accumulated value and current value.
accumulator + value } +3)
FoldInd intList.foldIndexed(10) { idx, 13 Accumulates values starting with initial and applying operation from left to right.
exed accumulator, value -> (10+1+2) Lambda receives index as the first value.
if (idx == 2) accumulator else

accumulator + value }

Aggregators (cont)
FoldRight intList.foldRight(10) { 16 Accumulates values starting with initial and applying operation from right to left.
accumulator, value -> (10+3+2 Lambda receives accumulated value and current value.
accumulator + value } +1)
FoldRightIn intList.foldRightIndexed(10) { 16 (10+3+2+1)

dexed idx, accumulator, value ->
Reduce intList.reduce { accumulator, 6 Accumulates values starting with first value and applying operation from left to
value -> (1+2+3) right. Lambda receives accumulated value and current value.
ReduceRig intList.reduceRight { 6 Accumulates values starting with first value and applying operation from right to
ht accumulator, value -> (3+2+1) left. Lambda receives accumulated value and current value.
ReduceInde intList.reduceIndexed { idx, 3 (1+2)

xed accumulator, value ->
ReduceRig intList.reduceRightIndexed { idx, 3 (2+1)

htIndexed accumulator, value ->
Grouping
GroupBy intList.groupBy { value -> 2 } {2=[1, Uses value returned from lamdba to group elements of the Iterable. All values
2, 3]} whose lambda returns same key will be grouped.

Aggregators (cont)
GroupBy intList.groupBy({ it }, { it + 1 }) {1= Same as group by plus takes another lambda that
(With new [2], can be used to transform the current value
values)
2=
[3],
3=
[4]}
GroupByTo val mutableStringToListMap = mapOf("first" to 1, {1= Group by first lambda, modify value with second
"second" to 2) [11], lambda, dump the values to given mutable map
2=
mutableStringToListMap.values.groupByTo(mutableMapOf<Int,
[12]}
MutableList<Int>>(), { value: Int -> value }, { value ->
value + 10 })
GroupingBy intList.groupingBy { it } {1=1, Create a grouping by a lambda, fold using passed

-> FoldTo .foldTo(mutableMapOf<Int, Int>(), 0) { accumulator, 2=2, in lambda and given initial value, insert into given
element -> 3=3} mutable destination object
accumulator + element }
Grouping > intList.groupingBy { "key" } {key Create a grouping by a lambda, aggregate each
Aggregate .aggregate({ key, accumulator: String?, element, isFirst =123} group. Lambda receives all keys, nullable
accumulator and the element plus a flag if value is
->
the first on from this group. If isFirst -->
when (accumulator) {
accumulator is null.
null -> "$element"
else -> accumulator + "$element"
}
})
Aggregating
Count intList.count() 3 AKA size
Count (with intList.count { it == 2 }) 1 Count of elements satisfying the predicate

Lambda)
Average intList.average() 2.0 Only for numeric Iterables

((1+2+
3)/3 =
2.0)
Max intList.max() 3 Maximum value in the list. Only for Iterables of

Comparables.
MaxBy intList.maxBy { it * 3 } 3 Maximum value returned from lambda. Only for

Lambdas returning Comparables.

Aggregators (cont)
MaxWith intList.maxWith(oneOrLarger) 1 Maximum value defined by passed in Comparator
Min intList.min() 1 Minimum value in the list. Only for Iterables of Comparables.
MinBy intList.minBy { it * 3 } 1 Minimum value returned from lambda. Only for Lambdas returning
Comparables.
MinWith intList.minWith(oneOrLarger) 3 Minimum value defined by passed in Comparator
Sum intList.sum() 6 Summation of all values in Iterable. Only numeric Iterables.
SumBy intList.sumBy { if(it == 3) 6 else 9 Summation of values returned by passed in lambda. Only for lambdas returning
it }) (1+2+6) numeric values.
SumByDou intList.sumByDouble { 6.0 Summation to Double values. Lambdareceives the value and returns a Double.
ble it.toDouble() }
val oneOrLarger = Comparator<Int> { x, y ->

when{
x == 1 -> 1
y == 1 -> -1
else -> y - x
}
}
Filtering and other predicates + simple HOFs
Method Example Result Notes
Filtering
Filter intList.filter { it > 2 } [3] Filter-in
FilterKeys aMap.filterKeys { it != "hello" } {hi=1}
FilterValue aMap.filterValues { it == 2 } {hello=2}

s
FilterIndex intList.filterIndexed { idx, value -> idx == 2 [2,3]

ed || value == 2 }
FilterIsInst intList.filterIsInstance<String>() [] All of them are ints

ance
Taking and Dropping
Take intList.take(2) [1,2] Take n elements from Iterable. If passed in number larger than
list, full list is returned.
TakeWhile intList.takeWhile { it < 3 } [1,2]
TakeLast intList.takeLast(2) [2,3]
TakeLastW intList.takeLastWhile { it < 3 } [] Last element already satisfies this condition --> empty
hile

Filtering and other predicates + simple HOFs (cont)
Drop intList.drop(2) [3] Drop n elements from the start of the Iterable.
DropWhile intList.dropWhile { it [3]

< 3 }
DropLast intList.dropLast(2) [1]
DropLastWhile intList.dropLastWhile { [1, 2]

it > 2 }
Retrieving individual elements
Component intList.component1() 1 There are 5 of these --> component1(), component2(), component3(),

component4(), component5()
ElementAt intList.elementAt(2) 3 Retrieve element at his index. Throws IndexOutOfBounds if element index doesn't
exist
ElementAtOrElse intList.elementAtOrElse( 4 Retrieve element at his index or return lambda value if element index doesn't exist.
13) { 4 }
ElementAtOrNull intList.elementAtOrNull( null Retrieve element at his index or return null if element index doesn't exist.
666)
Get (clumsy syntax) intList.get(2) 3 Get element by index
Get intList[2] 3 Shorthand and preferred way for the one above
GetOrElse intList.getOrElse(14) { 42 } 42 Get element or return lambda value if it doesn't exist.
Get from Map aMap.get("hi") 1

(clumsy syntax)
Get from Map aMap["hi"] 1
GetValue `aMap.getValue("hi")1 1 Get value or throw NoSuchElementException
GetOrDefault aMap.getOrDefault("HI", 4 Get value or return the value returned from lambda
4)
GetOrPut mutableMap.getOrPut("HI" 5 MutableMap only. Returns the the value if it exist, otherwise puts it and returns put
) { 5 } value.
Finding
BinarySearch intList.binarySearch(2) 1 Does a binary search through the collection and returns the index of the element if
found. Otherwise returns negative index.

Filtering and other predicates + simple HOFs (cont)
Find intList.find { it > 1 } 2 First element satisfying the condition or null if not found
FindLast intList.findLast { it > 1 } 3 Last element satisfying the condition or null if not found
First intList.first() 1 First element of Iterable or throws

NoSuchElementException
First with predicate intList.first { it > 1 } 2 Same as find but throws NoSuchElementException if not
found
FirstOrNull intList.firstOrNull() 1 Throw safe version of first().
FirstOrNull with intList.firstOrNull { it > 1 } 2 Throw safe version of first(() -> Boolean).
predicate
IndexOf intList.indexOf(1) 0
IndexOfFirst intList.indexOfFirst { it > 1 } 1
IndexOfLast intList.indexOfLast { it > 1 } 2
Last intList.last() 3 Throws NoSuchElementException if empty Iterable
Last with predicate intList.last { it > 1 } 3 Throws NoSuchElementException if none found satisfying
the condition.
LastIndexOf intList.lastIndexOf(2) 1
LastOrNull intList.lastOrNull() 3 Throw safe version of last()
LastOrNull with intList.lastOrNull { it > 1 } 3 Throw safe version of last(() -> Boolean) .
predicate
Unions, distincts, intersections etc.
Distinct intList.distinct() [1, 2, 3]
DistinctBy intList.distinctBy { if (it > 1) it [1,3]

else 2 }
Intersect intList.intersect(listOf(1, 2)) [1,2]
MinusElement intList.minusElement(2) [1,3]
MinusElement with intList.minusElement(listOf(1, 2)) [3]

collection
Single listOf("One Element").single() One Returns only element or throws.

Element
SingleOrNull intList.singleOrNull() null Throw safe version of single().
OrEmpty intList.orEmpty() [1, 2[, 3] Returns itself or an empty list if itself is null.
Union intList.union(listOf(4,5,6)) [1,2,3,4,5,6]
Union (infix notation) intList union listOf(4,5,6) [1,2,3,4,5,6]

Checks and Actions
Method Example Result Notes
Acting on list elements
val listOfFunctions = listOf({ print("first ") }, { print("second ") })
ForEach listOfFunctions.forEach { it() } first second
ForEachIndexed listOfFunctions.forEachIndexed { idx, fn -> if (idx == 0) fn() else first Won't do it

print("Won't do it") }
OnEach intList.onEach { print(it) } 123
Checks
All intList.all { it < 4 } true All of them are less

than 4
Any intList.any() true Collection has

elements
Any with intList.any { it > 4 } false None of them are more

predicate than 4
Contains intList.contains(3) true
ContainsAll intList.containsAll(listOf(2, 3, 4)) false
Contains (Map) aMap.contains("Hello") false Same as

containsKey()
ContainsKey aMap.containsKey("hello") true Same as

contains()
ContainsValue aMap.containsValue(2) true
None intList.none() false There are elements on

the list
None with intList.none { it > 5 } true None of them are

predicate larger than 5
IsEmpty intList.isEmpty() false
IsNotEmpty intList.isNotEmpty() true
<3 Kotlin
Github repository with all code examples:

https://github.com/Xantier/Kollections
PDF of this cheat sheet:

http://jussi.hallila.com/Kollections/
Created with <3 by Jussi Hallila


Xantier - Kotlin Collection Extensions

Uploaded by

Copyright:

Available Formats

Xantier - Kotlin Collection Extensions

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Xantier - Kotlin Collection Extensions

Uploaded by

Copyright:

Available Formats

Kotlin Collection Extensions Cheat Sheet

by Xantier via cheatography.com/38756/cs/12075/

Simple Array val intArray: Array<​Int> = arrayOf(1, 2, 3)

Copy of Array val copyOf​Array: Array<​Int> = intArr​ay.c​op​yOf()

Partial copy of val partia​lCo​pyO​fArray: Array<​Int> = intArr​ay.c​op​yOf​Ran​ge(0, 2)

Simple List val intList: List<I​nt> = listOf(1, 2, 3) Or array​Lis​tOf​(1,​2,3)

Empty List val emptyList: List<I​nt> = emptyL​ist() Or listOf()

List with no null val listWi​thN​onN​ull​Ele​ments: List<I​nt> = same as List(​1,3)

Simple Set val aSet: Set<In​t> = setOf(1) Or hashS​etO​f(1) / linke​dSe​rOf(1)

Empty Set val emptySet: Set<In​t> = emptyS​et() Or setOf() / hashS​etOf() / linke​dSe​tOf()

Simple Map val aMap: Map<St​ring, Int> = mapOf(​"​hi" to 1, Or mapOf​(Pa​ir(​"​hi", 1) / hashM​apO​f("h​i" to 1) /

Black sheep, mutables

Simple Mutable val mutabl​eList: Mutabl​eLi​st<​Int> = mutabl​eLi​stOf(1, 2, 3)

Simple Mutable val mutabl​eSet: Mutabl​eSe​t<I​nt> = mutabl​eSe​tOf(1)

Simple Mutable var mutabl​eMap: Mutabl​eMa​p<S​tring, Int> = mutabl​eMa​pOf​("hi​" to 1, "​hel​lo" to 2)

We will be using these collec​tions throughout the cheat sheet.

Method Exam​ple Result Expl​ana​tion

By Xantier Published 14th June, 2017. Sponsored by CrosswordCheats.com

Minus aMap - Pair("H​i", 2) {Hi=2} Takes in a key and removes if found

Method Exam​ple Result Expl​ana​tion

By Xantier Published 14th June, 2017. Sponsored by CrosswordCheats.com

MapInd​exe​d intLi​st.m​ap​Ind​exe​dNo​tNull [4,5] Combin​ation of Map, MapIndexed & MapInd​exe​dNo​tNull

Reversed intLi​st.r​ev​ers​ed()) [3,2,1]

Partition intLi​st.p​ar​tition { it > Pair(​[1,2], Splits collection into to based on predicate

Slice intLi​st.s​li​ce(​1..2)) [2,3] Takes a range from collection based on indexes

Sorted intLi​st.s​or​ted()) [1,2,3]

By Xantier Published 14th June, 2017. Sponsored by CrosswordCheats.com

Method Exam​ple Result Expl​ana​tion

Folds And Reduces

accumu​lator + value } +3)

if (idx == 2) accumu​lator else

By Xantier Published 14th June, 2017. Sponsored by CrosswordCheats.com

accumu​lator + value } +1)

FoldRi​ght​In intLi​st.f​ol​dRi​ght​Ind​exe​d(10) { 16 (10+3​+2+1)

Reduce​Inde intLi​st.r​ed​uce​Indexed { idx, 3 (1+2)

Reduce​Rig​ intLi​st.r​ed​uce​Rig​htI​ndexed { idx, 3 (2+1)

By Xantier Published 14th June, 2017. Sponsored by CrosswordCheats.com

GroupingBy intLi​st.g​ro​upingBy { it } {1=1, Create a grouping by a lambda, fold using passed

element -> 3=3} mutable destin​ation object

Count intLi​st.c​ou​nt() 3 AKA size

Count (with intLi​st.c​ount { it == 2 }) 1 Count of elements satisfying the predicate

Average intLi​st.a​ve​rage() 2.0 Only for numeric Iterables

Max intLi​st.m​ax() 3 Maximum value in the list. Only for Iterables of

MaxBy intLi​st.m​axBy { it * 3 } 3 Maximum value returned from lambda. Only for

By Xantier Published 14th June, 2017. Sponsored by CrosswordCheats.com

MaxWith intLi​st.m​ax​Wit​h(o​neO​rLa​rger) 1 Maximum value defined by passed in Comparator

MinWith intLi​st.m​in​Wit​h(o​neO​rLa​rger) 3 Minimum value defined by passed in Comparator

Sum intLi​st.s​um() 6 Summation of all values in Iterable. Only numeric Iterables.

val oneOrL​arger = Compar​ato​r<I​nt> { x, y ->

Filtering and other predicates + simple HOFs

Method Exam​ple Result Notes

Filter intLi​st.f​ilter { it > 2 } [3] Filter-in

FilterKeys aMap.f​il​terKeys { it != "​hel​lo" } {hi=1}

Filter​Value aMap.f​il​ter​Values { it == 2 } {hell​o=2}

Filter​Index intLi​st.f​il​ter​Indexed { idx, value -> idx == 2 [2,3]

Filter​IsI​nst intLi​st.f​il​ter​IsI​nst​anc​e<S​tri​ng>() [] All of them are ints

Taking and Dropping

TakeWhile intLi​st.t​ak​eWhile { it < 3 } [1,2]

TakeLast intLi​st.t​ak​eLa​st(2) [2,3]

Simple Array val intArray: Array<Int> = arrayOf(1, 2, 3)

Copy of Array val copyOfArray: Array<Int> = intArray.copyOf()

Partial copy of val partialCopyOfArray: Array<Int> = intArray.copyOfRange(0, 2)

Simple List val intList: List<Int> = listOf(1, 2, 3) Or arrayListOf(1,2,3)

Empty List val emptyList: List<Int> = emptyList() Or listOf()

List with no null val listWithNonNullElements: List<Int> = same as List(1,3)

Simple Set val aSet: Set<Int> = setOf(1) Or hashSetOf(1) / linkedSerOf(1)

Empty Set val emptySet: Set<Int> = emptySet() Or setOf() / hashSetOf() / linkedSetOf()

Simple Map val aMap: Map<String, Int> = mapOf("hi" to 1, Or mapOf(Pair("hi", 1) / hashMapOf("hi" to 1) /

Simple Mutable val mutableList: MutableList<Int> = mutableListOf(1, 2, 3)

Simple Mutable val mutableSet: MutableSet<Int> = mutableSetOf(1)

Simple Mutable var mutableMap: MutableMap<String, Int> = mutableMapOf("hi" to 1, "hello" to 2)

We will be using these collections throughout the cheat sheet.

Method Example Result Explanation

Minus aMap - Pair("Hi", 2) {Hi=2} Takes in a key and removes if found

Method Example Result Explanation

MapIndexed intList.mapIndexedNotNull [4,5] Combination of Map, MapIndexed & MapIndexedNotNull

Reversed intList.reversed()) [3,2,1]

Partition intList.partition { it > Pair([1,2], Splits collection into to based on predicate

Slice intList.slice(1..2)) [2,3] Takes a range from collection based on indexes

Sorted intList.sorted()) [1,2,3]

Method Example Result Explanation

accumulator + value } +3)

if (idx == 2) accumulator else

accumulator + value } +1)

FoldRightIn intList.foldRightIndexed(10) { 16 (10+3+2+1)

ReduceInde intList.reduceIndexed { idx, 3 (1+2)

ReduceRig intList.reduceRightIndexed { idx, 3 (2+1)

GroupingBy intList.groupingBy { it } {1=1, Create a grouping by a lambda, fold using passed

element -> 3=3} mutable destination object

Count intList.count() 3 AKA size

Count (with intList.count { it == 2 }) 1 Count of elements satisfying the predicate

Average intList.average() 2.0 Only for numeric Iterables

Max intList.max() 3 Maximum value in the list. Only for Iterables of

MaxBy intList.maxBy { it * 3 } 3 Maximum value returned from lambda. Only for

MaxWith intList.maxWith(oneOrLarger) 1 Maximum value defined by passed in Comparator

MinWith intList.minWith(oneOrLarger) 3 Minimum value defined by passed in Comparator

Sum intList.sum() 6 Summation of all values in Iterable. Only numeric Iterables.

val oneOrLarger = Comparator<Int> { x, y ->

Method Example Result Notes

Filter intList.filter { it > 2 } [3] Filter-in

FilterKeys aMap.filterKeys { it != "hello" } {hi=1}

FilterValue aMap.filterValues { it == 2 } {hello=2}

FilterIndex intList.filterIndexed { idx, value -> idx == 2 [2,3]

FilterIsInst intList.filterIsInstance<String>() [] All of them are ints

TakeWhile intList.takeWhile { it < 3 } [1,2]

TakeLast intList.takeLast(2) [2,3]

DropWhile intList.dropWhile { it [3]

DropLast intList.dropLast(2) [1]

DropLastWhile intList.dropLastWhile { [1, 2]

Component intList.component1() 1 There are 5 of these --> component1(), component2(), component3(),

Get (clumsy syntax) intList.get(2) 3 Get element by index

GetOrElse intList.getOrElse(14) { 42 } 42 Get element or return lambda value if it doesn't exist.

Get from Map aMap.get("hi") 1

Get from Map aMap["hi"] 1

GetValue `aMap.getValue("hi")1 1 Get value or throw NoSuchElementException

First intList.first() 1 First element of Iterable or throws

FirstOrNull intList.firstOrNull() 1 Throw safe version of first().

IndexOfFirst intList.indexOfFirst { it > 1 } 1

IndexOfLast intList.indexOfLast { it > 1 } 2

Last intList.last() 3 Throws NoSuchElementException if empty Iterable

LastOrNull intList.lastOrNull() 3 Throw safe version of last()

Unions, distincts, intersections etc.

Distinct intList.distinct() [1, 2, 3]

DistinctBy intList.distinctBy { if (it > 1) it [1,3]

Intersect intList.intersect(listOf(1, 2)) [1,2]

MinusElement intList.minusElement(2) [1,3]

MinusElement with intList.minusElement(listOf(1, 2)) [3]

Single listOf("One Element").single() One Returns only element or throws.

SingleOrNull intList.singleOrNull() null Throw safe version of single().

Union intList.union(listOf(4,5,6)) [1,2,3,4,5,6]

Union (infix notation) intList union listOf(4,5,6) [1,2,3,4,5,6]

Method Example Result Notes

val listOfFunctions = listOf({ print("first ") }, { print("second ") })

ForEach listOfFunctions.forEach { it() } first second

ForEachIndexed listOfFunctions.forEachIndexed { idx, fn -> if (idx == 0) fn() else first Won't do it

OnEach intList.onEach { print(it) } 123

All intList.all { it < 4 } true All of them are less

Any intList.any() true Collection has

Any with intList.any { it > 4 } false None of them are more