In this tutorial, we’ll show you many Kotlin HashMap methods and functions that also work on Android. You will see many examples to:
- Create, initialize, add item, get value, update, remove entries in a HashMap
- Iterate over a HashMap
- Filter a HashMap
- Convert HashMap to List, transform a HashMap keys or values
Related Posts:
– Kotlin List & Mutable List
– Kotlin Queue
Contents
- Overview of Kotlin HashMap
- Create a new HashMap
- Initialize a HashMap with values
- Add item to HashMap
- Kotlin HashMap get
- Kotlin HashMap get key by value
- Kotlin HashMap update values
- Check HashMap empty and size
- Check HashMap contains key/value
- Kotlin HashMap remove
- Iterate over a HashMap in Kotlin
- Kotlin HashMap filter
- Kotlin HashMap to List
- Kotlin transform HashMap keys
- Kotlin transform HashMap values
- Kotlin Hashmap with different value types
- Conclusion
- Further Reading
Overview of Kotlin HashMap
- A
HashMap
is a collection of key-value pairs that maps each key to exactly one value. HashMap
is unordered. The key-value pair coming later could be ordered first.- We can add an entry with
null
value ornull
key to KotlinHashMap
Create a new HashMap
We can create a new HashMap
using constructor.
If you want to create a new HashMap
that allows null values and null keys, just use the question mark ?
right after the types.
var hashMap: HashMap<String, Int> = HashMap<String, Int>()
var nullableHashMap: HashMap<String?, Int?> = HashMap<String?, Int?>()
Initialize a HashMap with values
The example show you way to initialize a HashMap
using hashMapOf() function:
var bzkMap: HashMap<String, Int> = hashMapOf("zero" to 0, "onek" to 1000, "twok" to 2000, "bezkoder" to 9999)
println(bzkMap)
Output:
{zero=0, onek=1000, twok=2000, bezkoder=9999}
Add item to HashMap
We can add an item (key-value pair) to a Kotlin HashMap
using:
- square brackets
[]
operator - put() method
var bzkMap: HashMap<String, Int> = HashMap<String, Int>()
bzkMap.put("bezkoder", 9999)
println("After put: " + bzkMap)
bzkMap["zero"] = 0
println("After []: " + bzkMap)
Output:
After put: {bezkoder=9999}
After []: {zero=0, bezkoder=9999}
You can also add all key/value pairs of another Map to current Map using putAll() method.
bzkMap.putAll(mapOf("onek" to 1000, "twok" to 2000))
println("After putAll: " + bzkMap)
Output:
After put: {bezkoder=9999}
After putAll: {zero=0, onek=1000, bezkoder=9999, twok=2000}
Kotlin HashMap get
The examples show you way to get value by key using:
- square brackets
[]
operator - get() method
- getOrElse() method that returns default value if there is no value for the key
- getOrPut() method that returns default value if there is no value for the key, and put the entry with key and default value to the HashMap
var bzkMap: HashMap<String, Int> = hashMapOf("onek" to 1000, "twok" to 2000, "bezkoder" to 9999)
bzkMap.get("bezkoder")
// 9999
bzkMap["bezkoder"]
// 9999
bzkMap.getOrElse("zkoder") { 123 }
// 123
// bzkMap: {onek=1000, twok=2000, bezkoder=9999}
bzkMap.getOrPut("zkoder") { 123 }
// 123
// bzkMap: {onek=1000, twok=2000, bezkoder=9999, zkoder=123}
We can get all keys or values with keys
& values
property.
bzkMap.keys
// [onek, twok, bezkoder, zkoder]
bzkMap.values
// [1000, 2000, 9999, 123]
Kotlin HashMap get key by value
We can find all keys that are paired with a given value using filterValues() method and Map’s keys
property.
For example, there are 2 entries with value = 9999
in the HashMap:
- {“zkoder”, 9999}
- {“bezkoder”, 9999}
var bzkMap: HashMap<String, Int> = hashMapOf("zkoder" to 9999, "year" to 2020, "bezkoder" to 9999)
val keys = bzkMap.filterValues { it == 9999 }.keys
println(keys)
Output:
[zkoder, bezkoder]
Kotlin HashMap update values
We can update values in HashMap by given existing keys using replace()
, put()
or square brackets []
.
var bzkMap: HashMap<String, Int> = hashMapOf("onek" to 1000, "twok" to 2000, "bezkoder" to 9999)
bzkMap.replace("bezkoder", 8888)
println(bzkMap)
bzkMap.put("bezkoder", 2020)
println(bzkMap)
bzkMap["bezkoder"] = 9999
println(bzkMap)
Output:
{onek=1000, twok=2000, bezkoder=8888}
{onek=1000, twok=2000, bezkoder=2020}
{onek=1000, twok=2000, bezkoder=9999}
Check HashMap empty and size
You can:
- find the number of key/value pairs using .size
- check if a Map is empty or not using isEmpty() or isNotEmpty() method
var bzkMap: HashMap<String, Int> = hashMapOf("onek" to 1000, "twok" to 2000, "bezkoder" to 9999)
println(bzkMap.size)
println(bzkMap.isEmpty())
println(bzkMap.isNotEmpty())
Output:
3
false
true
Check HashMap contains key/value
We can check existence of:
- a key using containsKey() method.
- a value using containsValue() method.
var bzkMap: HashMap<String, Int> = hashMapOf("onek" to 1000, "twok" to 2000, "bezkoder" to 9999)
bzkMap.containsKey("bezkoder") // true
bzkMap.containsKey("zkoder") // false
bzkMap.containsValue(1234) // false
bzkMap.containsValue(1000) // true
Kotlin HashMap remove
The examples show you how to:
- remove element (entry) by key using remove() method or
.keys.remove()
method - removes the first entry with the given value using
.values.remove()
method - remove all entries from a HashMap using clear() method
var bzkMap: HashMap<Int, String> =
hashMapOf(0 to "zero", 1 to "one", 2 to "two", 3 to "three", 4 to "four", 5 to "five")
bzkMap.remove(1)
println(bzkMap)
bzkMap.keys.remove(4)
println(bzkMap)
bzkMap.values.remove("zero")
println(bzkMap)
bzkMap.clear()
println(bzkMap)
Output:
{0=zero, 2=two, 3=three, 4=four, 5=five}
{0=zero, 2=two, 3=three, 5=five}
{2=two, 3=three, 5=five}
{}
Iterate over a HashMap in Kotlin
The examples show you how to iterate over a Kotlin HashMap using:
- forEach() method.
- simple for loop
var bzkMap: HashMap<Int, String> = hashMapOf(0 to "zero", 1 to "one", 2 to "two", 3 to "three")
bzkMap.forEach { (key, value) -> println("$key = $value") }
for ((key, value) in bzkMap) {
println("$key = $value")
}
Output:
0 = zero
1 = one
2 = two
3 = three
Kotlin HashMap filter
The examples show you how to filter a HashMap using:
- filterKeys() for new Map with keys matching the predicate
- filterValues() for new Map with values matching the
- filter() for both key and value in the predicate
var bzkMap: HashMap<String, Int> = hashMapOf("zero" to 0, "onek" to 1000, "twok" to 2000, "bezkoder" to 9999)
val filter1 = bzkMap.filterKeys { it.length < 5 }
println(filter1)
// {zero=0, onek=1000, twok=2000}
val filter2 = bzkMap.filterValues { it > 500 }
println(filter2)
// {onek=1000, twok=2000, bezkoder=9999}
val filter3 = bzkMap.filter { (key, value) -> key.length < 5 && value > 500 }
println(filter3)
// {onek=1000, twok=2000}
Kotlin HashMap to List
We can easily transform a Kotlin Map to List using map() method. It will return a new List with elements transformed from entries in original Map.
var bzkMap: HashMap<Int, String> = hashMapOf(0 to "zero", 1 to "one", 2 to "two", 3 to "three")
var bzkList = bzkMap.map { it.key.toString() + '-' + it.value }
println(bzkList)
Output:
[0-zero, 1-one, 2-two, 3-three]
Sometimes the transformation could produce null, so we filter out the nulls by using the mapNotNull() function instead of map()
var bzkList = bzkMap.mapNotNull { if (it.key == 0) null else it.key.toString() + '-' + it.value }
println(bzkList)
Output:
[1-one, 2-two, 3-three]
You can also use mapTo() and mapNotNullTo() with a destination as input pamameter.
var bzkList = mutableListOf<String>()
bzkMap.mapTo(bzkList) { it.key.toString() + '-' + it.value }
println(bzkList)
bzkList.clear()
bzkMap.mapNotNullTo(bzkList) { if (it.key == 0) null else it.key.toString() + '-' + it.value }
println(bzkList)
Output:
[0-zero, 1-one, 2-two, 3-three]
[1-one, 2-two, 3-three]
Kotlin transform HashMap keys
The example shows you how to transform HashMap keys in Kotlin using:
- mapKeys() method
- mapKeysTo() method with a destination
var bzkMap: HashMap<Int, String> = hashMapOf(0 to "zero", 1 to "one", 2 to "two", 3 to "three")
var keysMap = bzkMap.mapKeys { it.key * 100 }
println(keysMap)
var newKeysMap = mutableMapOf<Int, String>()
bzkMap.mapKeysTo(newKeysMap) { it.key * 1000 }
println(newKeysMap)
Output:
{0=zero, 100=one, 200=two, 300=three}
{0=zero, 1000=one, 2000=two, 3000=three}
Kotlin transform HashMap values
The example shows you how to transform HashMap values in Kotlin using:
- mapValues() method
- mapValuesTo() method with a destination
var bzkMap: HashMap<Int, String> = hashMapOf(0 to "zero", 1 to "one", 2 to "two", 3 to "three")
var valuesMap = bzkMap.mapValues { it.value.toUpperCase() }
println(valuesMap)
var newValuesMap = mutableMapOf<Int, String>()
bzkMap.mapValuesTo(newValuesMap) { '-' + it.value.toUpperCase() + '-' }
println(newValuesMap)
Output:
{0=ZERO, 1=ONE, 2=TWO, 3=THREE}
{0=-ZERO-, 1=-ONE-, 2=-TWO-, 3=-THREE-}
Kotlin Hashmap with different value types
To create a HashMap that can contain different value types, we use Any which is the supertype of all the other types.
val bzkMap = HashMap<String, Any>()
bzkMap.put("site", "bezkoder.com")
bzkMap.put("start", 2019)
bzkMap.put("working", true)
println(bzkMap)
Output:
{site=bezkoder.com, start=2019, working=true}
Conclusion
In this Kotlin tutorial, we’ve learned some important points of HashMap. Now you can create, initialize a HashMap, add, update and remove items from a HashMap. You also know way to iterate over a HashMap, filter or transform a HashMap.
Happy learning! See you again!