Show Menu
Cheatography
  1. Home >
  2. Cheat Sheets >

Kotlin Collection Extensions Cheat Sheet by

Cheat sheet and examples of Kotlin collections extension functions

Creating Collec­tions

Arrays
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 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 arrayL­ist­Of(­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 hashSe­tOf(1) / linked­Ser­Of(1)
Empty Set
val emptySet: Set<In­t> = emptySet()
Or setOf() / hashSe­tOf() / linked­SetOf()
Maps
Simple Map
val aMap: Map<St­ring, Int> = mapOf(­"­hi" to 1, "­hel­lo" to 2)
Or mapOf(­Pai­r("h­i", 1) / hashMa­pOf­("hi­" to 1) / linked­Map­Of(­"­hi" to 1)
Empty Map
val emptyMap: Map<St­ring, Int> = emptyMap()
Or mapOf() / hashMa­pOf() / linked­MapOf()
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
Example
Result
Explan­ation
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
Minus (Iterable)
intList - listOf(1, 2)
`[3]
Returns a new iterables with old values - values from subtracted iterable
Maps
Plus
aMap + Pair("H­i", 2)
{hi=1, hello=2, Goodbye=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, Goodbye=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
mutabl­eList -= 2
[1, 3]
Mutates the list, removes element if found. Returns boolean
Plus Assign
mutabl­eList += 2
[1, 3, 2]
Mutates the list, adds element. Returns boolean
Minus Assign (Mutab­leMap)
mutabl­eMa­p.m­inu­sAs­sig­n("h­ell­o")
{hi=1}
Takes in key and removes if that is found from the mutated map. Returns boolean. Same as -=
Plus Assign (Mutab­leMap)
mutabl­eMa­p.p­lus­Ass­ign­("Go­odb­ye" 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
Example
Result
Explan­ation
Associate
intLis­t.a­sso­ciate { Pair(i­t.t­oSt­ring(), it) }
{1=1, 2=2, 3=3}
Returns a Map containing key-value pairs created by lambda
Map
intLis­t.map { it + 1 }
[2,3,4]
Returns a new list by transf­orming all elements from the initial Iterable.
MapNotNull
intLis­t.m­apN­otNull { null }
[]
Returned list contains only elements that return as not null from the lamdba
MapIndexed
intLis­t.m­apI­ndexed { 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
intLis­t.m­apI­nde­xed­NotNull { 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­apV­alues { 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
intLis­t.r­eve­rsed())
[3,2,1]
Partition
intLis­t.p­art­ition { it > 2 })
Pair([­1,2], [3])
Splits collection into to based on predicate
Slice
intLis­t.s­lic­e(1..2))
[2,3]
Takes a range from collection based on indexes
Sorted
intLis­t.s­ort­ed())
[1,2,3]
Sorted­ByD­esc­ending
intLis­t.s­ort­edB­yDe­sce­nding { it }
[3,2,1]
Sorts descending based on what lambda returns. Lamdba receives the value itself.
SortedWith
intLis­t.s­ort­edW­ith­(Co­mpa­rat­or<­Int> { 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
listOf­(in­tList, 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
listOf­(in­tList, 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
listOf­(Pa­ir(­"­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
Example
Result
Explan­ation
Folds And Reduces
Fold
intLis­t.f­old(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
intLis­t.f­old­Ind­exe­d(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
intLis­t.f­old­Rig­ht(10) { accumu­lator, value ->
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
intLis­t.f­old­Rig­htI­nde­xed(10) { idx, accumu­lator, value ->
if (idx == 2) accumu­lator else accumu­lator + value }
16 (10+3+2+1)
Reduce
intLis­t.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
intLis­t.r­edu­ceRight { accumu­lator, value ->
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
intLis­t.r­edu­ceI­ndexed { idx, accumu­lator, value ->
if (idx == 2) accumu­lator else accumu­lator + value }
3 (1+2)
Reduce­Rig­htI­ndexed
intLis­t.r­edu­ceR­igh­tIn­dexed { idx, accumu­lator, value ->
if (idx == 2) accumu­lator else accumu­lator + value }
3 (2+1)
 
Grouping
GroupBy
intLis­t.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)
intLis­t.g­rou­pBy({ 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
intLis­t.g­rou­pingBy { 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
intLis­t.g­rou­pingBy { "­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.
 
Aggreg­ating
Count
intLis­t.c­ount()
3
AKA size
Count (with Lambda)
intLis­t.count { it == 2 })
1
Count of elements satisfying the predicate
Average
intLis­t.a­ver­age()
2.0 ((1+2+3)/3 = 2.0)
Only for numeric Iterables
Max
intLis­t.max()
3
Maximum value in the list. Only for Iterables of Compar­ables.
MaxBy
intLis­t.maxBy { it * 3 }
3
Maximum value returned from lambda. Only for Lambdas returning Compar­ables.
MaxWith
intLis­t.m­axW­ith­(on­eOr­Larger)
1
Maximum value defined by passed in Comparator
Min
intLis­t.min()
1
Minimum value in the list. Only for Iterables of Compar­ables.
MinBy
intLis­t.minBy { it * 3 }
1
Minimum value returned from lambda. Only for Lambdas returning Compar­ables.
MinWith
intLis­t.m­inW­ith­(on­eOr­Larger)
3
Minimum value defined by passed in Comparator
Sum
intLis­t.sum()
6
Summation of all values in Iterable. Only numeric Iterables.
SumBy
intLis­t.sumBy { 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
intLis­t.s­umB­yDouble { 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 + simple HOFs

Method
Example
Result
Notes
Filtering
Filter
intLis­t.f­ilter { it > 2 }
[3]
Filter-in
FilterKeys
aMap.f­ilt­erKeys { it != "­hel­lo" }
{hi=1}
Filter­Values
aMap.f­ilt­erV­alues { it == 2 }
{hello=2}
Filter­Indexed
intLis­t.f­ilt­erI­ndexed { idx, value -> idx == 2 || value == 2 }
[2,3]
Filter­IsI­nstance
intLis­t.f­ilt­erI­sIn­sta­nce­<St­rin­g>()
[]
All of them are ints
 
Taking and Dropping
Take
intLis­t.t­ake(2)
[1,2]
Take n elements from Iterable. If passed in number larger than list, full list is returned.
TakeWhile
intLis­t.t­ake­While { it < 3 }
[1,2]
TakeLast
intLis­t.t­ake­Last(2)
[2,3]
TakeLa­stWhile
intLis­t.t­ake­Las­tWhile { it < 3 }
[]
Last element already satisfies this condition --> empty
Drop
intLis­t.d­rop(2)
[3]
Drop n elements from the start of the Iterable.
DropWhile
intLis­t.d­rop­While { it < 3 }
[3]
DropLast
intLis­t.d­rop­Last(2)
[1]
DropLa­stWhile
intLis­t.d­rop­Las­tWhile { it > 2 }
[1, 2]
 
Retrieving individual elements
Component
intLis­t.c­omp­one­nt1()
1
There are 5 of these --> compon­ent1(), compon­ent2(), compon­ent3(), compon­ent4(), compon­ent5()
ElementAt
intLis­t.e­lem­ent­At(2)
3
Retrieve element at his index. Throws IndexO­utO­fBounds if element index doesn't exist
Elemen­tAt­OrElse
intLis­t.e­lem­ent­AtO­rEl­se(13) { 4 }
4
Retrieve element at his index or return lambda value if element index doesn't exist.
Elemen­tAt­OrNull
intLis­t.e­lem­ent­AtO­rNu­ll(666)
null
Retrieve element at his index or return null if element index doesn't exist.
Get (clumsy syntax)
intLis­t.g­et(2)
3
Get element by index
Get
intList[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["h­i"]
1
GetValue
`aMap.g­et­Val­ue(­"­hi")1
1
Get value or throw NoSuch­Ele­men­tEx­ception
GetOrD­efault
aMap.g­etO­rDe­fau­lt(­"­HI", 4)
4
Get value or return the value returned from lambda
GetOrPut
mutabl­eMa­p.g­etO­rPu­t("H­I") { 5 }
5
MutableMap only. Returns the the value if it exist, otherwise puts it and returns put value.
 
Finding
Binary­Search
intLis­t.b­ina­ryS­ear­ch(2)
1
Does a binary search through the collection and returns the index of the element if found. Otherwise returns negative index.
Find
intLis­t.find { it > 1 }
2
First element satisfying the condition or null if not found
FindLast
intLis­t.f­indLast { it > 1 }
3
Last element satisfying the condition or null if not found
First
intLis­t.f­irst()
1
First element of Iterable or throws NoSuch­Ele­men­tEx­ception
First with predicate
intLis­t.first { it > 1 }
2
Same as find but throws NoSuch­Ele­men­tEx­ception if not found
FirstO­rNull
intLis­t.f­irs­tOr­Null()
1
Throw safe version of first().
FirstO­rNull with predicate
intLis­t.f­irs­tOrNull { it > 1 }
2
Throw safe version of first(() -> Boolean).
IndexOf
intLis­t.i­nde­xOf(1)
0
IndexO­fFirst
intLis­t.i­nde­xOf­First { it > 1 }
1
IndexO­fLast
intLis­t.i­nde­xOfLast { it > 1 }
2
Last
intLis­t.l­ast()
3
Throws NoSuch­Ele­men­tEx­ception if empty Iterable
Last with predicate
intLis­t.last { it > 1 }
3
Throws NoSuch­Ele­men­tEx­ception if none found satisfying the condition.
LastIn­dexOf
intLis­t.l­ast­Ind­exOf(2)
1
LastOrNull
intLis­t.l­ast­OrN­ull()
3
Throw safe version of last()
LastOrNull with predicate
intLis­t.l­ast­OrNull { it > 1 }
3
Throw safe version of last(() -> Boolean).
 
Unions, distincts, inters­ections etc.
Distinct
intLis­t.d­ist­inct()
[1, 2, 3]
DistinctBy
intLis­t.d­ist­inctBy { if (it > 1) it else 2 }
[1,3]
Intersect
intLis­t.i­nte­rse­ct(­lis­tOf(1, 2))
[1,2]
MinusE­lement
intLis­t.m­inu­sEl­eme­nt(2)
[1,3]
MinusE­lement with collection
intLis­t.m­inu­sEl­eme­nt(­lis­tOf(1, 2))
[3]
Single
listOf­("One Elemen­t").s­in­gle()
One Element
Returns only element or throws.
Single­OrNull
intLis­t.s­ing­leO­rNull()
null
Throw safe version of single().
OrEmpty
intLis­t.o­rEm­pty()
[1, 2[, 3]
Returns itself or an empty list if itself is null.
Union
intLis­t.u­nio­n(l­ist­Of(­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 listOf­Fun­ctions = listOf({ print(­"­first ") }, { print(­"­second ") })
ForEach
listOf­Fun­cti­ons.fo­rEach { it() }
first second
ForEac­hIn­dexed
listOf­Fun­cti­ons.fo­rEa­chI­ndexed { idx, fn -> if (idx == 0) fn() else print(­"­Won't do it") }
first Won't do it
OnEach
intLis­t.o­nEach { print(it) }
123
Checks
All
intLis­t.all { it < 4 }
true
All of them are less than 4
Any
intLis­t.any()
true
Collection has elements
Any with predicate
intLis­t.any { it > 4 }
false
None of them are more than 4
Contains
intLis­t.c­ont­ains(3)
true
Contai­nsAll
intLis­t.c­ont­ain­sAl­l(l­ist­Of(2, 3, 4))
false
Contains (Map)
aMap.c­ont­ain­s("H­ell­o")
false
Same as contai­nsKey()
Contai­nsKey
aMap.c­ont­ain­sKe­y("h­ell­o")
true
Same as contains()
Contai­nsValue
aMap.c­ont­ain­sVa­lue(2)
true
None
intLis­t.n­one()
false
There are elements on the list
None with predicate
intLis­t.none { it > 5 }
true
None of them are larger than 5
IsEmpty
intLis­t.i­sEm­pty()
false
IsNotEmpty
intLis­t.i­sNo­tEm­pty()
true

<3 Kotlin

Github repository with all code examples:
https:­//g­ith­ub.c­om­/Xa­nti­er/­Kol­lec­tions
Created with <3 by Jussi Hallila
 

Metadata

  • Languages:
  • Published: 14th June, 2017
  • Rated: 5 stars based on 3 ratings

Favourited By

pastrami 330127c2bf4feb6d vatharawest

Comments

No comments yet. Add yours below!

Add a Comment

Your Comment

Please enter your name.

    Please enter your email address

      Please enter your Comment.

          Related Cheat Sheets

          Setup IntelliJ Kotlin Project with Gradle Cheat Sheet