Обзор коллекций

Коллекция

Collection<T> – корень иерархии коллекций. Этот интерфейс представляет общее поведение коллекции только для чтения: получение размера, проверку принадлежности элемента и так далее. Collection наследуется от интерфейса Iterable<T>, который определяет операции для итерирования элементов. Вы можете использовать Collection в качестве параметра функции, которая применяется к различным типам коллекций. Для более конкретных случаев используйте наследников Collection: List и Set.

fun printAll(strings: Collection<String>) {
    for(s in strings) print("$s ")
    println()
}
    
fun main() {
    val stringList = listOf("one", "two", "one")
    printAll(stringList)
    
    val stringSet = setOf("one", "two", "three")
    printAll(stringSet)
}

MutableCollection<T> – это Collection с операциями записи, такими как add и remove.

fun List<String>.getShortWordsTo(shortWords: MutableList<String>, maxLength: Int) {
    this.filterTo(shortWords) { it.length <= maxLength }
    // throwing away the articles
    val articles = setOf("a", "A", "an", "An", "the", "The")
    shortWords -= articles
}

fun main() {
    val words = "A long time ago in a galaxy far far away".split(" ")
    val shortWords = mutableListOf<String>()
    words.getShortWordsTo(shortWords, 3)
    println(shortWords)
}

Список

List<T> хранит элементы в заданном порядке и предоставляет индексированный доступ к ним. Индексы начинаются с нуля – индекс первого элемента – и доходят до lastIndex, который является (list.size - 1).

fun main() {
//sampleStart
    val numbers = listOf("one", "two", "three", "four")
    println("Number of elements: ${numbers.size}")
    println("Third element: ${numbers.get(2)}")
    println("Fourth element: ${numbers[3]}")
    println("Index of element \"two\" ${numbers.indexOf("two")}")
//sampleEnd
}

Элементы списка (включая null) могут дублироваться: список может содержать любое количество одинаковых объектов или вхождений одного объекта. Два списка считаются равными, если у них одинаковый размер и структурно равные элементы в тех же позициях.

data class Person(var name: String, var age: Int)

fun main() {
//sampleStart
    val bob = Person("Bob", 31)
    val people = listOf(Person("Adam", 20), bob, bob)
    val people2 = listOf(Person("Adam", 20), Person("Bob", 31), bob)
    println(people == people2)
    bob.age = 32
    println(people == people2)
//sampleEnd
}

MutableList<T> – это List со специфичными для списков операциями записи, например, для добавления или удаления элемента в определённой позиции.

fun main() {
//sampleStart
    val numbers = mutableListOf(1, 2, 3, 4)
    numbers.add(5)
    numbers.removeAt(1)
    numbers[0] = 0
    numbers.shuffle()
    println(numbers)
//sampleEnd
}

Как видите, в некоторых аспектах списки очень похожи на массивы. Однако есть одно важное различие: размер массива определён при инициализации и никогда не меняется; в свою очередь, у списка нет предопределённого размера; размер списка может меняться в результате операций записи: добавления, обновления или удаления элементов.

В Kotlin, по умолчанию, реализацией MutableList является ArrayList, которую можно представить как изменяемый массив.

Множество

Set<T> хранит уникальные элементы; их порядок, как правило, не определён. null элементы также уникальны: Set может содержать только один null. Два множества равны, если они имеют одинаковый размер, и для каждого элемента одного множества существует равный элемент в другом множестве.

fun main() {
//sampleStart
    val numbers = setOf(1, 2, 3, 4)
    println("Number of elements: ${numbers.size}")
    if (numbers.contains(1)) println("1 is in the set")

    val numbersBackwards = setOf(4, 3, 2, 1)
    println("The sets are equal: ${numbers == numbersBackwards}")
//sampleEnd
}

MutableSet – это Set с операциями записи из MutableCollection.

По умолчанию реализацией MutableSet – LinkedHashSet – сохраняется порядок вставки элементов. Следовательно, функции, которые зависят от порядка, такие как first() или last(), возвращают предсказуемые результаты для таких множеств.

fun main() {
//sampleStart
    val numbers = setOf(1, 2, 3, 4)  // LinkedHashSet is the default implementation
    val numbersBackwards = setOf(4, 3, 2, 1)
    
    println(numbers.first() == numbersBackwards.first())
    println(numbers.first() == numbersBackwards.last())
//sampleEnd
}

Альтернативная реализация – HashSet – не говорит ничего о порядке элементов, поэтому вызов таких функций на ней возвращает непредсказуемые результаты. Однако, HashSet требует меньше памяти для хранения того же количества элементов.

Карта

Map<K, V> не является наследником интерфейса Collection, но это тоже тип коллекции Kotlin. Map хранит пары ключ-значение (или элементы); ключи уникальны, но разные ключи могут быть сопоставлены с равными значениями. Интерфейс Map предоставляет специфичные функции, такие как доступ к значению по ключу, поиск ключей и значений и так далее.

fun main() {
//sampleStart
    val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)
    
    println("All keys: ${numbersMap.keys}")
    println("All values: ${numbersMap.values}")
    if ("key2" in numbersMap) println("Value by key \"key2\": ${numbersMap["key2"]}")    
    if (1 in numbersMap.values) println("The value 1 is in the map")
    if (numbersMap.containsValue(1)) println("The value 1 is in the map") // same as previous
//sampleEnd
}

Две карты, содержащие одинаковые пары, равны независимо от порядка пар.

fun main() {
//sampleStart
    val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)    
    val anotherMap = mapOf("key2" to 2, "key1" to 1, "key4" to 1, "key3" to 3)
    
    println("The maps are equal: ${numbersMap == anotherMap}")
//sampleEnd
}

MutableMap – это Map с операциями записи карты, например, вы можете добавить новую пару ключ-значение или обновить значение, связанное с заданным ключом.

fun main() {
//sampleStart
    val numbersMap = mutableMapOf("one" to 1, "two" to 2)
    numbersMap.put("three", 3)
    numbersMap["one"] = 11

    println(numbersMap)
//sampleEnd
}

По умолчанию, реализацией MutableMap является LinkedHashMap, которая сохраняет порядок вставки элементов при итерировании по карте. В свою очередь, альтернативная реализация – HashMap – ничего не говорит о порядке элементов.