Construct from elements
The most common way to create a collection is with the standard library functions
mutableSetOf<T>(). If you provide a comma-separated list of collection elements as arguments, the compiler detects the element type automatically. When creating empty collections, specify the type explicitly.
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.
There are also functions for creating collections without any elements:
emptyMap(). When creating empty collections, you should specify the type of elements that the collection will hold.
Initializer functions for lists
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
To create a concrete type collection, such as an
LinkedList, you can use the available constructors for these types. Similar constructors are available for implementations of
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
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.
These functions can also be used for converting collections to other types, for example, build a set from a list or vice versa.
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.
Collection initialization can be used for restricting mutability. For example, if you create a
List reference to a
MutableList, the compiler will produce errors if you try to modify the collection through this reference.
Invoke 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:
Mapping produces a list of a transformation results:
Association produces maps:
For more information about operations on collections in Kotlin, see Collection operations overview.