Constructing Collections

    The same is available for maps with the functions mapOf() and . The map’s keys and values are passed as Pair objects (usually created with to infix function).

    1. val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)

    Note that the to notation creates a short-living Pair object, so it’s recommended that you use it only if performance isn’t critical. To avoid excessive memory usage, use alternative ways. For example, you can create a mutable map and populate it using the write operations. The apply() function can help to keep the initialization fluent here.

    1. val numbersMap = mutableMapOf<String, String>().apply { this["one"] = "1"; this["two"] = "2" }

    Empty collections

    There are also functions for creating collections without any elements: emptyList(), , and emptyMap(). When creating empty collections, you should specify the type of elements that the collection will hold.

    1. val empty = emptyList<String>()

    For lists, there is a constructor that takes the list size and the initializer function that defines the element value based on its index.

    Concrete type constructors

    1. val linkedList = LinkedList<String>(listOf("one", "two", "three"))
    2. val presizedSet = HashSet<Int>(32)

    To create a collection with the same elements as an existing collection, you can use copying operations. Collection copying operations from the standard library create shallow copy collections with references to the same elements. Thus, a change made to a collection element reflects in all its copies.

    Collection copying functions, such as toList(), , toSet() and others, create a snapshot of a collection at a specific moment. Their result is a new collection of the same elements. If you add or remove elements from the original collection, this won’t affect the copies. Copies may be changed independently of the source as well.

    1. fun main() {
    2. //sampleStart
    3.     val sourceList = mutableListOf(1, 2, 3)
    4.     val copyList = sourceList.toMutableList()
    5.     val readOnlyCopyList = sourceList.toList()
    6.     sourceList.add(4)
    8.     //readOnlyCopyList.add(4)             // compilation error
    9.     println("Read-only copy size: ${readOnlyCopyList.size}")
    10. //sampleEnd
    11. }

    These functions can also be used for converting collections to other types, for example, build a set from a list or vice versa.

    1. fun main() {
    2. //sampleStart
    3.     val sourceList = mutableListOf(1, 2, 3)    
    4.     val copySet = sourceList.toMutableSet()
    5.     copySet.add(3)
    6.     copySet.add(4)    
    7.     println(copySet)
    8. //sampleEnd
    9. }

    Alternatively, you can create new references to the same collection instance. New references are created when you initialize a collection variable with an existing collection. So, when the collection instance is altered through a reference, the changes are reflected in all its references.

    1. fun main() {
    2. //sampleStart 
    3.     val sourceList = mutableListOf(1, 2, 3)
    4.     //referenceList.add(4)            //compilation error
    5.     sourceList.add(4)
    6.     println(referenceList) // shows the current state of sourceList
    7. //sampleEnd
    8. }

    Invoking functions on other collections

    Collections can be created in result of various operations on other collections. For example, filtering a list creates a new list of elements that match the filter:

    1. fun main() {
    2. //sampleStart 
    3.     val numbers = listOf("one", "two", "three", "four")  
    4.     val longerThan3 = numbers.filter { it.length > 3 }
    5.     println(longerThan3)
    6. //sampleEnd
    7. }

    produces a list of a transformation results:

    1. fun main() {
    2. //sampleStart 
    3.     val numbers = setOf(1, 2, 3)
    4.     println(numbers.map { it * 3 })
    5.     println(numbers.mapIndexed { idx, value -> value * idx })
    6. }

    Association produces maps:

    For more information about operations on collections in Kotlin, see .