Какие знаешь особенности коллекций в Kotlin?

Особенности коллекций в Kotlin

Kotlin, как язык, работающий на JVM и совместимый с Java, предоставляет удобный API для работы с коллекциями, построенный поверх стандартных Java-коллекций. Однако Kotlin вносит существенные улучшения, делая работу с коллекциями более безопасной и выразительной.

Разделение на Immutable и Mutable коллекции

Одна из ключевых особенностей Kotlin — явное разделение между неизменяемыми (immutable) и изменяемыми (mutable) коллекциями:

// Immutable коллекции (только чтение)
val readOnlyList: List<String> = listOf("a", "b", "c")
val readOnlyMap: Map<String, Int> = mapOf("one" to 1, "two" to 2)
val readOnlySet: Set<Int> = setOf(1, 2, 3)

// Mutable коллекции (можно изменять)
val mutableList: MutableList<String> = mutableListOf("a", "b")
mutableList.add("c")

val mutableMap: MutableMap<String, Int> = mutableMapOf("one" to 1)
mutableMap["two"] = 2

val mutableSet: MutableSet<Int> = mutableSetOf(1, 2)
mutableSet.add(3)

Этот подход улучшает безопасность кода и делает намерения разработчика явными. Если функция принимает List, это гарантирует, что коллекция не будет изменена.

Функциональное программирование с коллекциями

Kotlin предоставляет мощный набор функций для функционального программирования с коллекциями: map, filter, reduce, fold, groupBy и многие другие.

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

val people = listOf(
    Person("Alice", 30),
    Person("Bob", 25),
    Person("Charlie", 35)
)

// Фильтрация и преобразование
val adults = people.filter { it.age >= 30 }
val names = adults.map { it.name }

// Группировка
val groupedByAge = people.groupBy { it.age }

// Reduce и fold
val sum = listOf(1, 2, 3, 4).reduce { acc, value -> acc + value }
val product = listOf(1, 2, 3, 4).fold(1) { acc, value -> acc * value }

// Any, all, none
val hasAdult = people.any { it.age >= 30 }
val allAdults = people.all { it.age >= 30 }
val noChildren = people.none { it.age < 18 }

Последовательности (Sequences)

Kotlin вводит концепцию Sequence — лениво вычисляемых коллекций, похожих на потоки в Java 8, но с лучшей интеграцией.

// Eager evaluation (немедленное выполнение)
val list = listOf(1, 2, 3, 4, 5)
val result1 = list.filter { println("filter: $it"); it > 2 }
                  .map { println("map: $it"); it * 2 }
                  .toList()

// Lazy evaluation (отложенное выполнение)
val sequence = listOf(1, 2, 3, 4, 5).asSequence()
val result2 = sequence.filter { println("filter: $it"); it > 2 }
                      .map { println("map: $it"); it * 2 }
                      .toList()  // Выполняется только при вызове toList()

Сложное преобразование запустится только один раз через последовательность, а не дважды через промежуточные коллекции.

Деструктуризация и диапазоны

Kotlin позволяет удобно работать с коллекциями через деструктуризацию и диапазоны:

// Деструктуризация
val (first, second, third) = listOf(1, 2, 3)

// В циклах
val pairs = listOf(1 to "one", 2 to "two")
for ((num, word) in pairs) {
    println("$num -> $word")
}

// Диапазоны
val range = 1..10
for (i in range) println(i)

val reverseRange = 10 downTo 1 step 2
for (i in reverseRange) println(i)

if (5 in range) println("5 is in range")

Удобные методы для работы с коллекциями

Kotlin добавляет множество полезных методов:

val list = listOf(1, 2, 3, 4, 5)

// Получение элементов
val first = list.first() // 1
val last = list.last()   // 5
val middle = list[2]     // 3

// Поиск элементов
val found = list.find { it > 3 }      // 4
val foundIndex = list.indexOfFirst { it > 3 } // 3

// Трансформация
val distinct = list.distinct()        // 1, 2, 3, 4, 5
val reversed = list.reversed()        // 5, 4, 3, 2, 1
val paired = list.zipWithNext()       // (1,2), (2,3), (3,4)...

// Статистика
val sum = list.sum()                 // 15
val average = list.average()         // 3.0
val maxValue = list.maxOrNull()      // 5

Nullability и безопасность

Kotlin строго типизирует коллекции и разделяет элементы с и без null:

// Коллекция без null элементов
val nonNullList: List<String> = listOf("a", "b")

// Коллекция с возможными null элементами
val nullableList: List<String?> = listOf("a", null, "b")

// Методы для безопасной работы с null
val result = nullableList.filterNotNull()  // List<String> без null
val mapped = nullableList.mapNotNull { it?.uppercase() }

Итоги

Основные преимущества работы с коллекциями в Kotlin:

1. Явное разделение immutable и mutable коллекций
2. Функциональный API с богатым набором операций
3. Sequence для ленивых вычислений и оптимизации производительности
4. Синтаксический сахар для деструктуризации и диапазонов
5. Nullability встроена в систему типов
6. Удобные методы для работы с элементами