Массивы

Массив со значениями

Чтобы создать типизированный массив из заранее известных значений, используйте функцию arrayOf(). Kotlin автоматически выводит тип:

fun main() {
//sampleStart
    val simpleArray = arrayOf(1, 2, 3) // Array<Int>
    println(simpleArray.joinToString())
    // 1, 2, 3
//sampleEnd
}

Пустой массив

Чтобы создать массив без элементов, используйте функцию emptyArray(). Тип элементов можно указать слева или справа от знака присваивания:

val emptyArrayRight = emptyArray<String>()
val emptyArrayLeft: Array<String> = emptyArray()

Узнайте, как добавлять элементы в массив.

Массив со значениями null

Чтобы создать массив заданного размера, заполненный элементами null, используйте функцию arrayOfNulls():

fun main() {
//sampleStart
    val nullArray: Array<Int?> = arrayOfNulls(3)
    println(nullArray.joinToString())
    // null, null, null
//sampleEnd
}

Конструктор массива

Конструктор Array принимает размер массива и функцию, которая возвращает значения его элементов:

fun main() {
//sampleStart
    val zeroes = Array<Int>(3) { 0 }
    println(zeroes.joinToString())
    // 0, 0, 0
    
    val squares = Array(5) { i -> i * i }
    println(squares.joinToString())
    // 0, 1, 4, 9, 16
//sampleEnd
}

Вложенные массивы

Чтобы создать вложенный или многомерный массив, используйте массив массивов. Вложенные массивы могут иметь разные типы и размеры.

fun main() {
//sampleStart
    // Creates a two-dimensional array
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }
    println(twoDArray.contentDeepToString())
    // [[0, 0], [0, 0]]

    // Creates a three-dimensional array
    val threeDArray = Array(3) { Array(3) { Array<Int>(3) { 0 } } }
    println(threeDArray.contentDeepToString())
    // [[[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
//sampleEnd
}

Массивы примитивных типов

Если использовать класс Array с примитивными значениями, компилятор упаковывает их в объекты. Чтобы избежать дополнительных затрат на упаковку, можно использовать специализированные массивы примитивных типов. Они не являются подклассами класса Array<T>, но предоставляют аналогичный набор функций и свойств.

Чтобы создать массив примитивных типов, воспользуйтесь одним из следующих способов:

• Функции-конструкторы:

  fun main() {
  //sampleStart
      // Creates an Int array of size 5 with the values initialized to zero
      val primitiveTypeArray = IntArray(5)
      println(primitiveTypeArray.joinToString())
      // 0, 0, 0, 0, 0
  
      // Creates an Int array and takes an initializer function
      val squares = IntArray(5) { i -> i * i }
      println(squares.joinToString())
      // 0, 1, 4, 9, 16
  //sampleEnd
  }
  

• Функции-фабрики:

  fun main() {
  //sampleStart
      // Creates an Int array with 5 elements
      val numbers = intArrayOf(1, 2, 3, 4, 5)
      println(numbers.joinToString())
      // 1, 2, 3, 4, 5
  
      // Creates a Char array with 3 elements
      val characters = charArrayOf('K', 't', 'l')
      println(characters.joinToString())
      // K, t, l
  
      // Creates a Double array with 3 elements
      val doubles = doubleArrayOf(0.22, 4.16, 0.5)
      println(doubles.joinToString()) 
      // 0.22, 4.16, 0.5
  //sampleEnd
  }
  

Доступ к элементам и их изменение

Для доступа к элементам массива и их изменения используйте оператор индексированного доступа ([]):

fun main() {
//sampleStart
    val simpleArray = arrayOf(1, 2, 3)
    val twoDArray = Array(2) { Array<Int>(2) { 0 } }

    // Accesses the element and modifies it
    simpleArray[0] = 10
    twoDArray[0][0] = 2

    // Prints the modified element
    println(simpleArray[0]) 
    // 10
    println(twoDArray[0][0]) 
    // 2
//sampleEnd
}

Также можно использовать функцию fill(element, fromIndex, toIndex), чтобы заменить элементы в диапазоне на месте. fromIndex включается в диапазон, а toIndex — нет:

fun main() {
//sampleStart
    val arr = IntArray(3)
    println(arr.joinToString())
    // 0, 0, 0
    
   arr.fill(1)
   println(arr.joinToString())
   // 1, 1, 1
  
   arr.fill(0, 0, 2)
   println(arr.joinToString())
   // 0, 0, 1
//sampleEnd
}

В Kotlin массивы инвариантны. Это означает, что Array<String> не является подтипом Array<Any>. Это предотвращает возможные ошибки типов во время выполнения. Чтобы выразить ковариантность, используйте проекцию типа Array<out Any>:

fun main() {
//sampleStart
    fun printArr(arr: Array<out Any>) {
        for (item in arr) print("$item, ")
    }

    printArr(arrayOf("k", "t", "n"))  
    // k, t, n, 
//sampleEnd
}

Добавление и удаление элементов

Поскольку размер массивов фиксирован, они не поддерживают функции .add() и .remove(). Для выполнения этих операций необходимо создать новый массив. Для этого можно воспользоваться одним из следующих способов:

• Используйте функцию .copyOf:

  fun main() {
  //sampleStart
      var arr = intArrayOf(0, 1, 2)
  
      arr = arr.copyOf(arr.size + 1)
      println(arr.joinToString())
      // 0, 1, 2, 0
  
      arr[arr.lastIndex] = 3
      println(arr.joinToString())
      // 0, 1, 2, 3
  //sampleEnd
  }
  

• Используйте операторы + или +=:

  fun main() {
  //sampleStart
      var arr = intArrayOf(0, 1, 2)
  
      arr += 3
      println(arr.joinToString())
      // 0, 1, 2, 3
  
      arr = arr + intArrayOf(4, 5)
      println(arr.joinToString())
      // 0, 1, 2, 3, 4, 5
  //sampleEnd
  }
  

Сравнение массивов

Чтобы проверить, содержат ли два массива одинаковые элементы в одном и том же порядке, используйте функции .contentEquals() и .contentDeepEquals():

fun main() {
//sampleStart
    val simpleArray = arrayOf(1, 2, 3)
    val anotherArray = arrayOf(1, 2, 3)

    // Compares contents of arrays
    println(simpleArray.contentEquals(anotherArray))
    // true

    // Using infix notation, compares contents of arrays after an element 
    // is changed
    simpleArray[0] = 10
    println(simpleArray contentEquals anotherArray)
    // false
//sampleEnd
}

Преобразование массивов

В Kotlin есть множество полезных функций для преобразования массивов. В этом разделе рассмотрены некоторые из них. Полный список см. в справочнике API.

fun main() {
//sampleStart
    val sumArray = arrayOf(1, 2, 3)
    println(sumArray.sum())
    // 6
//sampleEnd
}

fun main() {
//sampleStart
    val simpleArray = arrayOf(1, 2, 3)

    // Randomly shuffles elements
    simpleArray.shuffle()
    println(simpleArray.joinToString())
  
    // Sorts elements
    simpleArray.sort()
    println(simpleArray.joinToString())
    // 1, 2, 3
//sampleEnd
}

Передача функции переменного количества аргументов

В Kotlin функции можно передать переменное количество аргументов с помощью параметра vararg. Это полезно, когда заранее неизвестно число аргументов, например при форматировании сообщения или создании SQL-запроса.

Чтобы передать функции массив, содержащий переменное количество аргументов, используйте оператор развёртывания (*). Он передаёт каждый элемент массива выбранной функции как отдельный аргумент:

fun main() {
    val lettersArray = arrayOf("c", "d")
    printAllStrings("a", "b", *lettersArray)
    // abcd
}

fun printAllStrings(vararg strings: String) {
    for (string in strings) {
        print(string)
    }
}

Дополнительную информацию см. в разделе Переменное количество аргументов (varargs).

Преобразование в List или Set

Чтобы преобразовать массив в List или Set, используйте функции .toList() и .toSet():

fun main() {
//sampleStart
    val simpleArray = arrayOf("a", "b", "c", "c")

    // Converts to a Set
    println(simpleArray.toSet())
    // [a, b, c]

    // Converts to a List
    println(simpleArray.toList())
    // [a, b, c, c]
//sampleEnd
}

Не используйте .asList() и связанные функции as*, если вы не уверены, что исходный массив не изменится и не используется совместно где-либо ещё. Эти функции создают обёртку вокруг исходного массива, а не копируют его. Поэтому изменения массива отражаются в списке, и наоборот.

fun main() {
//sampleStart
    val simpleArray = arrayOf("a", "b", "c")

    val list = simpleArray.asList()
    simpleArray[0] = "d"
    println(list)
    // [d, b, c]
//sampleEnd
}

Преобразование в Map

Чтобы преобразовать массив в Map, используйте функцию .toMap().

В Map можно преобразовать только массив из элементов типа Pair<K,V>. Первое значение экземпляра Pair становится ключом, а второе — значением. Если один и тот же ключ встречается несколько раз, используется последнее значение.

В этом примере для вызова функции .to используется инфиксная нотация, чтобы создать пары из Pair:

fun main() {
//sampleStart
    val pairArray = arrayOf("apple" to 120, "banana" to 150, "cherry" to 90, "apple" to 140)

    // Converts to a Map
    // Fruits are keys, calorie numbers are values
    // The latest "apple" value overwrites the first one
    println(pairArray.toMap())
    // {apple=140, banana=150, cherry=90}
//sampleEnd
}