Collection

Класс для работы с массивами фиксированного размера. Он хранит элементы одного типа и предоставляет индексированный доступ к ним.

val array = arrayOf(1, 2, 3)
array[0] = 10 // Изменение элемента
println(array[0]) // 10

// Пример для массива
val numbers = arrayOf(1, 2, 3, 4, 5)
val stringRepresentation = numbers.contentToString()
println(stringRepresentation) // Output: [1, 2, 3, 4, 5]

Интерфейс коллекции элементов, которые можно перебрать.

Неизменяемую коллекцию элементов.

val collection: Collection<Int> = listOf(1, 2, 3)
println(collection.contains(2)) // true

val mutableCollection: MutableCollection<Int> = mutableListOf(1, 2, 3)
mutableCollection.add(4)
mutableCollection.remove(2)
println(mutableCollection) // [1, 3, 4]

Неизменяемый список.

val list = listOf(1, 2, 3)
println(list[0]) // 1

val list = mutableListOf(1, 2, 3)
list.add(4)
list[1] = 5
println(list) // [1, 5, 3, 4]

Неизменяемая коллекция уникальных элементов.

val set = setOf(1, 2, 3, 3)
println(set) // [1, 2, 3]

val set = mutableSetOf(1, 2, 3)
set.add(4)
println(set) // [1, 2, 3, 4]

Изменяемый ассоциативный массив.

val map = mapOf("a" to 1, "b" to 2)
println(map["a"]) // 1

val map: MutableMap<String, Int> = mutableMapOf()
map["one"] = 1  // Добавление
map.put("two", 2)  // Альтернативный способ
println(map["one"])  // Выводит: 1
map.remove("one")  // Удаление
println(map)  // Выводит: {two=2}

Последовательности представляет собой ленивую коллекцию, которая позволяет эффективно работать с большими объемами данных или сложными цепочками преобразований. Основная особенность Sequence — это ленивое выполнение, что означает, что элементы вычисляются по мере необходимости, а не сразу.

• Вычисляет элементы только при необходимости, а не сразу при создании. Это позволяет избежать лишних вычислений и экономит ресурсы. Это особенно полезно при работе с большими данными или при выполнении сложных цепочек преобразований.

• Методы, такие как map, filter, и flatMap возвращают новый Sequence, который будет вычисляться при итерации. Преобразования применяются по цепочке, что минимизирует количество проходов по данным.

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

// Элементы фильтруются и преобразуются по мере необходимости, а не сразу.
val numbers = (1..10).asSequence()
val result = numbers
    .filter { it % 2 == 0 }
    .map { it * it }
    .toList()

println(result) // Output: [4, 16, 36, 64, 100]

// Сначала вся коллекция умножается на 2, а затем результат фильтруется, что приводит к двум проходам по данным.
val result = listOf(1, 2, 3, 4, 5)
    .map { it * 2 }
    .filter { it % 3 == 0 }
    .toList()

// Каждый элемент будет умножен на 2, проверен на делимость на 3 и сохранен в результат, что минимизирует количество операций.
val result = listOf(1, 2, 3, 4, 5)
    .asSequence()
    .map { it * 2 }
    .filter { it % 3 == 0 }
    .toList()

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

val transformedSequence = sequence.map { it * 2 }

val filteredSequence = sequence.filter { it % 2 == 0 }

val infiniteSequence = generateSequence(1) { it + 1 }
val firstFive = infiniteSequence.take(5).toList()
println(firstFive) // Output: [1, 2, 3, 4, 5]

• Collections (10)

  1. Kакие типы коллекции существуют в Kotlin?

     List MutableList Set MutableSet Map MutableMap

  2. Зачем в Kotlin коллекции делятся на mutable и immutable?

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

  3. Разница между mutable и immutable коллекциями в Kotlin?

     Mutable коллекции позволяют изменять свои элементы, тогда как immutable коллекции не допускают изменений после создания, требуя создания новых экземпляров при модификации.

  4. Во что Mutable-коллекции Kotlin превращаются в Java?

     Mutable-коллекции в Kotlin превращаются в стандартные изменяемые коллекции Java.

     • MutableList становится java.util.List.

     • MutableSet превращается в java.util.Set.

     • MutableMap становится java.util.Map.

  5. Как работает функция map для коллекций в Kotlin?

     Применяет функцию transform к каждому элементу исходной коллекции и возвращает новую коллекцию.

  6. Как получить уникальные объекты из списка?

     Использовать оператор distinct(). Этот метод сохраняет порядок элементов и убирает дубликаты.

  7. Как написать свою функцию map для коллекции?

     Вот так, используя inline:

     inline fun <T, R> List<T>.map(transform: (T) -> R): List<R> {
         val result = mutableListOf<R>()
         for (item in this) {
             result.add(transform(item))
         }
         return result
     }

  8. Какой будет тип и что выведется?

     var shortChars = listOf("1", "2")
     var shortNumbers2 = listOf(1, 2)
     println(
     		shortChars
     				.reversed()
     				.map { it.toInt() }
     				.zip(shortNumbers2) { a, b ->
     						"$a+$b"
     				}
     )

     Тип будет List. Вывод: [2+1, 1+2].

  9. Что напечатает println?

     val map = mutableMapOf("ZeroKey" to "0")
         .plus(
             "FirstKey" to "1",
         ).apply {
             this.plus("SecondKey" to "2")
         }
     println(map.values)

     [0]

  10. Будет ли работать это код, как исправить?

      val moviesYears = mutableListOf(
          1999, 2001, 2012,
          2014, 2015, 2017
      )
      
      for (year in moviesYears)
          if (year >= 2014)
              moviesYears.remove(year)

      Код не будет работать корректно, так как нельзя изменять коллекцию (moviesYears) во время её итерации — это может привести к пропуску элементов. Исправить можно, используя removeIf.

• Sequences (5)

  1. Для чего нужен Sequence?

     Для ленивой обработки коллекций, когда операции применяются к элементам по мере их запроса, что позволяет экономить память и избегать лишних вычислений, особенно с большими наборами данных.

  2. Как Sequence работает с точки зрения памяти?

     Sequence использует меньше памяти в хипе, так как обрабатывает элементы лениво, создавая их только по мере необходимости и не загружая всю коллекцию в память сразу. Каждый вызов последовательной операции над Sequence создаёт объект, который ссылается на следующий элемент, освобождая память по мере завершения обработки текущих элементов.

  3. Разница между Collection и Sequences?

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

  4. В каких случаях Sequence лучше Collections?

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

  5. Как будут выполняться эти операторы? Как улучшить метод чтобы было меньше накладных расходов?

     fun foo3(items: MutableList<Item>) {
     		return items
     				.filterIsInstance<ShiftInterval>()
     				.filter { it.isChecked }
     				.groupBy(...)
     				.mapKeys { ... }
     				.flatMap { ... }
     }

     Операторы будут выполняться последовательно, каждый создавая промежуточные коллекции. Чтобы уменьшить накладные расходы, можно заменить последовательность операций на ленивую обработку с использованием последовательностей (Sequence), что позволит избежать создания промежуточных коллекций. Использование items.asSequence() делает операции ленивыми и уменьшает накладные расходы, так как коллекции не будут создаваться на каждом этапе.