Kotlin Collections and Collection Extension Functions Cheat Sheet Creating Collec­tions Arrays Simple Array val intArray: Array<­Int> = arrayOf(1, 2, 3) Simple Array of Primitives val primitiveIntArray: IntArray = intArrayOf(1, 2, 3) Or doubleArrayOf(1,2,3) / longArrayOf(1,2,3) / floatArrayOf(1,2,3) etc. Copy of Array val copyOf­Array: Array<­Int> = intArr­ay.c­op­yOf() Partial copy of Array val partia­lCo­pyO­fArray: Array<­Int> = intArr­ay.c­op­yOf­Ran­ge(0, 2) Lists 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 elements val listWi­thN­onN­ull­Ele­ments: List<I­nt> = listOf­Not­Null(1, null, 3) same as List(­1,3) Sets 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() Maps Simple Map val aMap: Map<St­ring, Int> = mapOf(­"­hi" to 1, "­hel­lo" to 2) Or mapOf­(Pa­ir(­"­hi", 1) / hashM­apO­f("h­i" to 1) / linke­dMa­pOf­("hi­" to 1) Empty Map val emptyMap: Map<St­ring, Int> = emptyM­ap() Or mapOf() / hashM­apOf() / linke­dMa­pOf() Black sheep, mutables Simple Mutable List val mutabl­eList: Mutabl­eLi­st<­Int> = mutabl­eLi­stOf(1, 2, 3) Simple Mutable Set val mutabl­eSet: Mutabl­eSe­t<I­nt> = mutabl­eSe­tOf(1) Simple Mutable Map 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. Operators Method Exam­ple Result Expl­ana­tion Itera­bles 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] Returns a new iterable with old values + values from added iterable Minus intList - 1 [2, 3] Returns a new iterable with old values - subtracted one Minus (Iterable) intList - listOf(1, 2) [3] Returns a new iterable with old values without the values from subtracted iterable Maps Plus aMap + Pair("H­i", 2) {hi=1, hello=2, Goodby­e=3} Returns new map with old map values + new Pair. Updates value if it differs Plus (Map) aMap + mapOf(­

Pai­r("h­ell­o", 2), Pair("G­ood­bye­", 3)) {hi=1, hello=2, Goodby­e=3} Returns new map with old map values + Pairs from added map. Updates values if they differ. Minus aMap - Pair("H­i", 2) {Hi=2} Takes in a key and removes if found Minus (Map) aMap - listOf­("he­llo­", "­hi") {} Takes in an iterable of keys and removes if found Mutables Minus Assign mutab­leList -= 2 [1, 3] Mutates the list, removes element if found. Returns boolean Plus Assign mutab­leList += 2 [1, 3, 2] Mutates the list, adds element. Returns boolean Minus Assign (Mutab­leMap) mutab­leM­ap.m­in­usA­ssi­gn(­"­hel­lo") {hi=1} Takes in key and removes if that is found from the mutated map. Returns boolean. Same as -= Plus Assign (Mutab­leMap) mutab­leM­ap.p­lu­sAs­sig­n("G­ood­bye­" to 3) {hi=1, Goodbye=3} Takes in key and adds a new pair into the mutated map. Returns boolean. Same as += Transf­ormers Method Exam­ple Result Expl­ana­tion Associate intLi­st.a­ss­ociate {

Pair(i­t.t­oSt­ring(), it)

} {1=1, 2=2, 3=3} Returns a Map containing key-value pairs created by lambda Map intLi­st.map { it + 1 } [2,3,4] Returns a new list by transf­orming all elements from the initial Iterable. MapNotNull intLi­st.m­ap­NotNull { null } [] Returned list contains only elements that return as not null from the lamdba MapIndexed intLi­st.m­ap­Indexed{ idx, value ->

if (idx == 0) value + 1 else value + 2

} [2,4,5] Returns a new list by transf­orming all elements from the initial Iterable. Lambda receives an index as first value, element itself as second. MapInd­exe­dNo­tNull intLi­st.m­ap­Ind­exe­dNo­tNull { idx, value ->

if (idx == 0) null else value + 2

} [4,5] Combin­ation of Map, MapIndexed & MapInd­exe­dNo­tNull MapKeys aMap.m­apKeys { pair -> pair.key + ", mate" } {hi, mate=1, hello, mate=2} Transforms all elements from a map. Receives a Pair to lambda, lamdba return value is the new key of original value MapValues aMap.m­ap­Values { pair -> pair.value + 2 }) {hi=3, hello=4} Transforms all elements from a map. Receives a Pair to lambda, lamdba return value is the new value for the original key. Reversed intLi­st.r­ev­ers­ed()) [3,2,1] Partition intLi­st.p­ar­tition { it > 2 }) Pair(­[3], [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] Sorted­ByD­esc­ending intLi­st.s­or­ted­ByD­esc­ending { it } [3,2,1] Sorts descending based on what lambda returns. Lamdba receives the value itself. SortedWith intLi­st.s­or­ted­Wit­h(C­omp­ara­tor­<In­t> { x, y ->

when {

x == 2 -> 1

y == 2 -> -1

else -> y - x

}

}) [3,1,2] Takes in a Comparator and uses that to sort elements in Iterable. Flatten listO­f(i­ntList, aSet).f­la­tten() [2,3,­4,1] Takes elements of all passed in collec­tions and returns a collection with all those elements FlatMap with just return listO­f(i­ntList, aSet).f­latMap { it } [2,3,­4,1] Used for Iterable of Iterables and Lambdas that return Iterables. Transforms elements and flattens them after transf­orm­ation. FlatMap with transform listOf­(in­tList, aSet).f­latMap {

iterable: Iterab­le<­Int> ->

iterable.map { it + 1 }

} [2,3,­4,2] FlatMap is often used with monadic containers to fluently handle context, errors and side effects. Zip listOf(3, 4).zip­(in­tList) [(3,1), (4,2)] Creates a list of Pairs from two Iterables. As many pairs as values in shorter of the original Iterables. Zip with predicate listOf(3, 4).zip­(in­tList) {

firstElem, secondElem ->

Pair(firstElem - 2, secondElem + 2)

} [(1,3), (2,4)] Creates a list of Pairs from two Iterables. As many pairs as values in shorter of the original Iterables. Lambda receives both items on that index from Iterables. Unzip listO­f(P­air­("hi­", 1), Pair("h­ell­o", 2)).un­zip() Pair([hi, hello], [1,2]) Reverses the operation from zip . Takes in an Iterable of Pairs and returns them as a Pair of Lists. Aggreg­ators Method Exam­ple Result Expl­ana­tion Folds And Reduces Fold intLi­st.f­ol­d(10) { accumu­lator, value ->

accumu­lator + value

} 16 (10+1­+2+3) Accumu­lates values starting with initial and applying operation from left to right. Lambda receives accumu­lated value and current value. FoldIn­dexed intLi­st.f­ol­dIn­dex­ed(10) { idx, accumu­lator, value ->

if (idx == 2) accumu­lator else accumu­lator + value } 13 (10+1+2) Accumu­lates values starting with initial and applying operation from left to right. Lambda receives index as the first value. FoldRight intLi­st.f­ol­dRi­ght(10) { value, accumulator ->

accumu­lator + value

} 16 (10+3­+2+1) Accumu­lates values starting with initial and applying operation from right to left. Lambda receives accumu­lated value and current value. FoldRi­ght­Indexed intLi­st.f­ol­dRi­ght­Ind­exe­d(10) { idx, value, accumulator ->

if (idx == 2) accumu­lator else accumu­lator + value

} 16 (10+3­+2+1) Reduce intLi­st.r­educe { accumu­lator, value ->

accumu­lator + value

} 6 (1+2+3) Accumu­lates values starting with first value and applying operation from left to right. Lambda receives accumu­lated value and current value. Reduce­Right intLi­st.r­ed­uce­Right { value, accumulator ->

accumu­lator + value

} 6 (3+2+1) Accumu­lates values starting with first value and applying operation from right to left. Lambda receives accumu­lated value and current value. Reduce­Indexed intLi­st.r­ed­uce­Indexed { idx, accumu­lator, value ->

if (idx == 2) accumu­lator else accumu­lator + value

} 3 (1+2) Reduce­Rig­htI­ndexed intLi­st.r­ed­uce­Rig­htI­ndexed { idx, value, accumulator ->

if (idx == 2) accumu­lator else accumu­lator + value

} 3 (2+1) Grouping GroupBy intLi­st.g­roupBy { value -> 2 } {2=[1, 2, 3]} Uses value returned from lamdba to group elements of the Iterable. All values whose lambda returns same key will be grouped. GroupBy (With new values) intLi­st.g­ro­upBy({ it }, { it + 1 }) {1=[2], 2=[3], 3=[4]} Same as group by plus takes another lambda that can be used to transform the current value GroupByTo val mutabl­eSt­rin­gTo­ListMap = mapOf(­"­fir­st" to 1,

"­sec­ond­" to 2)

mutableStringToListMap.values.groupByTo(

mutableMapOf<Int, Mutabl­eLi­st<­Int­>>(), {

value: Int -> value }, { value -> value + 10 }) {1=[11], 2=[12]} Group by first lambda, modify value with second lambda, dump the values to given mutable map GroupingBy -> FoldTo intLi­st.g­ro­upingBy { it }

.foldTo(mutableMapOf<Int, Int>(), 0) {

accumu­lator, element ->

accumu­lator + element

} {1=1, 2=2, 3=3} Create a grouping by a lambda, fold using passed in lambda and given initial value, insert into given mutable destin­ation object Grouping > Aggregate intLi­st.g­ro­upingBy { "­key­" }

.aggregate({

key, accumu­lator: String?,

element, isFirst ->

­ when (accum­ulator) {

­ ­ ­ null -> "­$el­eme­nt"

­ ­ ­ else -> accumu­lator + "­$el­eme­nt"

­ }

}) {key=­123} Create a grouping by a lambda, aggregate each group. Lambda receives all keys, nullable accumu­lator and the element plus a flag if value is the first on from this group. If isFirst --> accumu­lator is null. Chunked val list = listOf("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten")



list.chunked(3) [[one, two, three],

[four, five, six],

[seven, eight, nine],

[ten]] Splits this collection into a list of lists each not exceeding the given size

The last list in the resulting list may have less elements than the given size. Aggregating Count intLi­st.c­ou­nt() 3 AKA size Count (with Lambda) intLi­st.c­ount { it == 2 }) 1 Count of elements satisfying the predicate Average intLi­st.a­ve­rage() 2.0 ((1+2­+3)/3 = 2.0) Only for numeric Iterables Max intLi­st.m­ax() 3 Maximum value in the list. Only for Iterables of Compar­ables. MaxBy intLi­st.m­axBy { it * 3 } 3 Maximum value returned from lambda. Only for Lambdas returning Compar­ables. MaxWith intLi­st.m­ax­Wit­h(o­neO­rLa­rger) 1 Maximum value defined by passed in Comparator Min intLi­st.m­in() 1 Minimum value in the list. Only for Iterables of Compar­ables. MinBy intLi­st.m­inBy { it * 3 } 1 Minimum value returned from lambda. Only for Lambdas returning Compar­ables. 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. SumBy intLi­st.s­umBy { if(it == 3) 6 else it }) 9 (1+2+6) Summation of values returned by passed in lambda. Only for lambdas returning numeric values. SumByD­ouble intLi­st.s­um­ByD­ouble { it.toD­ouble() } 6.0 Summation to Double values. Lambda­rec­eives the value and returns a Double. val oneOrL­arger = Compar­ato­r<I­nt> { x, y ->

­ when{

­ ­ ­ x == 1 -> 1

­ ­ ­ y == 1 -> -1

­ ­ ­ else -> y - x

­ }

} Filtering and other predicates + getting individual elements Method Exam­ple Result Notes Filtering Filter intLi­st.f­ilter { it > 2 } [3] Filter-in FilterKeys aMap.f­il­terKeys { it != "­hel­lo" } {hi=1} Filter­Values aMap.f­il­ter­Values { it == 2 } {hell­o=2} Filter­Indexed intLi­st.f­il­ter­Indexed { idx, value ->

idx == 2 || value == 2

} [2,3] Filter­IsI­nstance intLi­st.f­il­ter­IsI­nst­anc­e<S­tri­ng>() [] Type parameter defines the class instance. None returned because in our list all of them are ints Taking and Dropping Take intLi­st.t­ak­e(2) [1,2] Take n elements from Iterable. If passed in number larger than list, full list is returned. TakeWhile intLi­st.t­ak­eWhile { it < 3 } [1,2] TakeLast intLi­st.t­ak­eLa­st(2) [2,3] TakeLa­stWhile intLi­st.t­ak­eLa­stWhile { it < 3 } [] Last element already satisfies this condition --> empty Drop intLi­st.d­ro­p(2) [3] Drop n elements from the start of the Iterable. DropWhile intLi­st.d­ro­pWhile { it < 3 } [3] DropLast intLi­st.d­ro­pLa­st(2) [1] DropLa­stWhile intLi­st.d­ro­pLa­stWhile { it > 2 } [1, 2] Retrieving individual elements Component intLi­st.c­om­pon­ent1() 1 There are 5 of these --> compo­nen­t1() , compo­nen­t2() , compo­nen­t3() , compo­nen­t4() , compo­nen­t5() ElementAt intLi­st.e­le­men­tAt(2) 3 Retrieve element at his index. Throws IndexO­utO­fBounds if element index doesn't exist Elemen­tAt­OrElse intLi­st.e­le­men­tAt­OrE­lse(13) { 4 } 4 Retrieve element at his index or return lambda value if element index doesn't exist. Elemen­tAt­OrNull intLi­st.e­le­men­tAt­OrN­ull­(666) null Retrieve element at his index or return null if element index doesn't exist. Get (clumsy syntax) intLi­st.g­et(2) 3 Get element by index Get intLi­st[2] 3 Shorthand and preferred way for the one above GetOrElse intLis­t.g­etO­rEl­se(14) { 42 } 42 Get element or return lambda value if it doesn't exist. Get from Map (clumsy syntax) aMap.g­et­("hi­") 1 Get from Map aMap[­"­hi"] 1 GetValue aMap.g­et­Val­ue(­"­hi")1 1 Get value or throw NoSuch­Ele­men­tEx­ception GetOrD­efault aMap.g­et­OrD­efa­ult­("HI­", 4) 4 Get value or return the value returned from lambda GetOrPut mutab­leM­ap.g­et­OrP­ut(­"­HI") { 5 } 5 MutableMap only. Returns the the value if it exist, otherwise puts it and returns put value. Finding Binary­Search intLi­st.b­in­ary­Sea­rch(2) 1 Does a binary search through the collection and returns the index of the element if found. Otherwise returns negative index. Find intLi­st.find { it > 1 } 2 First element satisfying the condition or null if not found FindLast intLi­st.f­in­dLast { it > 1 } 3 Last element satisfying the condition or null if not found First intLi­st.f­ir­st() 1 First element of Iterable or throws NoSuch­Ele­men­tEx­ception First with predicate intLi­st.f­irst { it > 1 } 2 Same as find but throws NoSuch­Ele­men­tEx­ception if not found FirstO­rNull intLi­st.f­ir­stO­rNu­ll() 1 Throw safe version of first() . FirstO­rNull with predicate intLi­st.f­ir­stO­rNull { it > 1 } 2 Throw safe version of first(() -> Boolean) . IndexOf intLi­st.i­nd­exO­f(1) 0 IndexO­fFirst intLi­st.i­nd­exO­fFirst { it > 1 } 1 IndexO­fLast intLi­st.i­nd­exO­fLast { it > 1 } 2 Last intLi­st.l­ast() 3 Throws NoSuch­Ele­men­tEx­ception if empty Iterable Last with predicate intLi­st.last { it > 1 } 3 Throws NoSuch­Ele­men­tEx­ception if none found satisfying the condition. LastIn­dexOf intLi­st.l­as­tIn­dex­Of(2) 1 LastOrNull intLi­st.l­as­tOr­Null() 3 Throw safe version of last() LastOrNull with predicate intLi­st.l­as­tOrNull { it > 1 } 3 Throw safe version of last(() -> Boolean) . Unions, distincts, inters­ections etc. Distinct intLi­st.d­is­tin­ct() [1, 2, 3] DistinctBy intLi­st.d­is­tinctBy { if (it > 1) it else 2 } [1,3] Intersect intLi­st.i­nt­ers­ect­(li­stOf(1, 2)) [1,2] MinusE­lement intLi­st.m­in­usE­lem­ent(2) [1,3] MinusE­lement with collection intLi­st.m­in­usE­lem­ent­(li­stOf(1, 2)) [3] Single listO­f("One Elemen­t").s­in­gle() One Element Returns only element or throws. Single­OrNull intLi­st.s­in­gle­OrN­ull() null Throw safe version of singl­e() . OrEmpty intLi­st.o­rE­mpty() [1, 2, 3] Returns itself or an empty list if itself is null. Union intLi­st.u­ni­on(­lis­tOf­(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 Exam­ple Result Notes Acting on list elements val listOf­Fun­ctions = listOf({ print(­"­first ") }, { print(­"­second ") }) ForEach listO­fFu­nct­ion­s.f­orEach { it() } first second ForEac­hIn­dexed listO­fFu­nct­ion­s.f­orE­ach­Indexed { idx, fn ->

if (idx == 0) fn() else print(­"­Won't do it")

} first Won't do it OnEach intLi­st.o­nEach { print(it) } 123 Checks All intLi­st.all { it < 4 } true All of them are less than 4 Any intLi­st.a­ny() true Collection has elements Any with predicate intLi­st.any { it > 4 } false None of them are more than 4 Contains (standard) intLi­st.c­on­tai­ns(3) true Contains (idiomatic Kotlin) 3 in intList true Contai­nsAll intLi­st.c­on­tai­nsA­ll(­lis­tOf(2, 3, 4)) false Contains (Map, standard) aMap.c­on­tai­ns(­"­Hel­lo") false Same as conta­ins­Key() Contains (Map, Idiomatic Kotlin) "Hello" in aMap false Same as conta­ins­Key() Contai­nsKey aMap.c­on­tai­nsK­ey(­"­hel­lo") true Same as conta­ins() Contai­nsValue aMap.c­on­tai­nsV­alu­e(2) true None intLi­st.n­one() false There are elements on the list None with predicate intLi­st.none { it > 5 } true None of them are larger than 5 IsEmpty intLi­st.i­sE­mpty() false IsNotEmpty intLi­st.i­sN­otE­mpty() true <3 Kotlin

https://github.com/Xantier/Kollections

Contributions Welcome! Github repository with all code examples:Contributions Welcome!

Download PDF of this cheat sheet: Created with <3 by Jussi Hallila Originally created with the help of Cheatography.