Kotlin Collections: Lists, Sets, and Maps

Collections are an essential part of any programming language, providing a way to group and manage related data. Kotlin, a modern and expressive language, offers robust support for collections, including lists, sets, and maps. These collections are part of Kotlin’s standard library and provide various functionalities to store, retrieve, and manipulate data efficiently.

In this guide, we will explore Kotlin’s collection types, focusing on lists, sets, and maps. We will cover how to create, access, and modify these collections, as well as common operations that can be performed on them. By understanding these fundamental data structures, you will be able to write more efficient and clean Kotlin code.

Table of Contents

Lists

A list in Kotlin is an ordered collection of elements that can contain duplicates. Lists are useful when you need to maintain the order of elements and allow access by index.

Creating Lists

Kotlin provides several ways to create lists. You can use the listOf function to create an immutable list or the mutableListOf function to create a mutable list.

fun main() {

    val immutableList = listOf("Apple", "Banana", "Cherry")
    val mutableList = mutableListOf("Apple", "Banana", "Cherry")

}

In this example, immutableList is an immutable list, meaning its elements cannot be changed after creation. mutableList is a mutable list, allowing modifications.

Accessing List Elements

You can access elements in a list by their index using the bracket notation.

fun main() {

    val immutableList = listOf("Apple", "Banana", "Cherry")
    val mutableList = mutableListOf("Apple", "Banana", "Cherry")

    val firstElement = immutableList[0]
    println(firstElement) // Output: Apple

}

Here, we access the first element of immutableList using its index.

Modifying Lists

For mutable lists, you can add, remove, and update elements.

fun main() {

    val immutableList = listOf("Apple", "Banana", "Cherry")
    val mutableList = mutableListOf("Apple", "Banana", "Cherry")

    mutableList.add("Date")
    println(mutableList) // Output: [Apple, Banana, Cherry, Date]

    mutableList[1] = "Blueberry"
    println(mutableList) // Output: [Apple, Blueberry, Cherry, Date]

    mutableList.removeAt(2)
    println(mutableList) // Output: [Apple, Blueberry, Date]

}

In this example, we add “Date” to mutableList, update the second element to “Blueberry”, and remove the third element.

Sets

A set in Kotlin is an unordered collection that does not allow duplicate elements. Sets are useful when you need to ensure that all elements are unique.

Creating Sets

You can create sets using the setOf function for immutable sets and the mutableSetOf function for mutable sets.

fun main() {

    val immutableSet = setOf("Apple", "Banana", "Cherry")
    val mutableSet = mutableSetOf("Apple", "Banana", "Cherry")

}

Here, immutableSet is an immutable set, and mutableSet is a mutable set.

Accessing Set Elements

While sets do not support indexing, you can check for the presence of elements using the contains method.

fun main() {

    val immutableSet = setOf("Apple", "Banana", "Cherry")
    val mutableSet = mutableSetOf("Apple", "Banana", "Cherry")

    val hasApple = immutableSet.contains("Apple")
    println(hasApple) // Output: true

}

In this example, we check if “Apple” is present in immutableSet.

Modifying Sets

For mutable sets, you can add and remove elements.

fun main() {

    val immutableSet = setOf("Apple", "Banana", "Cherry")
    val mutableSet = mutableSetOf("Apple", "Banana", "Cherry")

    mutableSet.add("Date")
    println(mutableSet) // Output: [Apple, Banana, Cherry, Date]

    mutableSet.remove("Banana")
    println(mutableSet) // Output: [Apple, Cherry, Date]

}

Here, we add “Date” to mutableSet and remove “Banana” from it.

Maps

A map in Kotlin is a collection of key-value pairs. Maps are useful when you need to associate values with unique keys.

Creating Maps

You can create maps using the mapOf function for immutable maps and the mutableMapOf function for mutable maps.

fun main() {

    val immutableMap = mapOf("A" to "Apple", "B" to "Banana", "C" to "Cherry")
    val mutableMap = mutableMapOf("A" to "Apple", "B" to "Banana", "C" to "Cherry")

}

In this example, immutableMap is an immutable map, and mutableMap is a mutable map.

Accessing Map Elements

You can access values in a map by their keys using the bracket notation.

fun main() {

    val immutableMap = mapOf("A" to "Apple", "B" to "Banana", "C" to "Cherry")
    val mutableMap = mutableMapOf("A" to "Apple", "B" to "Banana", "C" to "Cherry")

    val value = immutableMap["A"]
    println(value) // Output: Apple

}

Here, we access the value associated with the key “A” in immutableMap.

Modifying Maps

For mutable maps, you can add, update, and remove key-value pairs.

fun main() {

    val immutableMap = mapOf("A" to "Apple", "B" to "Banana", "C" to "Cherry")
    val mutableMap = mutableMapOf("A" to "Apple", "B" to "Banana", "C" to "Cherry")

    mutableMap["D"] = "Date"
    println(mutableMap) // Output: {A=Apple, B=Banana, C=Cherry, D=Date}

    mutableMap["B"] = "Blueberry"
    println(mutableMap) // Output: {A=Apple, B=Blueberry, C=Cherry, D=Date}

    mutableMap.remove("C")
    println(mutableMap) // Output: {A=Apple, B=Blueberry, D=Date}

}

In this example, we add a new key-value pair to mutableMap, update the value for key “B”, and remove the key-value pair with key “C”.

Common Collection Operations

Kotlin collections support various operations that make it easy to manipulate and transform data.

Filtering

The filter function allows you to filter elements based on a predicate.

fun main() {

    val immutableList = listOf("Apple", "Banana", "Cherry")

    val filteredList = immutableList.filter { it.startsWith("B") }
    println(filteredList) // Output: [Banana]

}

Here, we filter immutableList to include only elements that start with “B”.

Mapping

The map function transforms each element in the collection using a specified function.

fun main() {

    val immutableList = listOf("Apple", "Banana", "Cherry")

    val lengths = immutableList.map { it.length }
    println(lengths) // Output: [5, 6, 6]

}

In this example, we transform immutableList to a list of the lengths of each string.

Reducing

The reduce function combines all elements in the collection into a single value using a specified function.

fun main() {

    val immutableList = listOf("Apple", "Banana", "Cherry")

    val concatenated = immutableList.reduce { acc, s -> "$acc, $s" }
    println(concatenated) // Output: Apple, Banana, Cherry

}

Here, we use reduce to concatenate all strings in immutableList into a single string.

Conclusion

Kotlin’s collections framework provides powerful and flexible tools for managing data. Lists, sets, and maps are fundamental data structures that allow you to store, retrieve, and manipulate data efficiently. By understanding how to use these collections and the operations available, you can write more robust and maintainable Kotlin code.

Additional Resources

To further your understanding of Kotlin collections, consider exploring the following resources:

Kotlin Documentation: The official documentation for Kotlin. Kotlin Documentation
Kotlin by JetBrains: Learn Kotlin through official JetBrains resources. Kotlin by JetBrains
Kotlin for Android Developers: A comprehensive guide to using Kotlin for Android development. Kotlin for Android Developers
Kotlin Koans: Interactive exercises to learn Kotlin. Kotlin Koans
KotlinConf Talks: Watch talks from the Kotlin conference. KotlinConf Talks