Как добавить элемент в массив kotlin
Перейти к содержимому

Как добавить элемент в массив kotlin

  • автор:

Операции записи коллекций

Изменяемые коллекции поддерживают операции, изменяющие её содержимое, например, операции по добавлению и удалению элементов. В этом разделе описаны операции записи, доступные для всех реализаций MutableCollection . Более конкретные операции, доступные для List и Map , описаны в разделах List: специфичные операции и Map: специфичные операции.

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

Чтобы добавить один элемент в список или множество ( Set ), используйте функцию add() . Указанный объект будет добавлен в конец коллекции.

fun main() < val numbers = mutableListOf(1, 2, 3, 4) numbers.add(5) println(numbers) // [1, 2, 3, 4, 5] >

Функция addAll() добавляет все элементы из переданного в качестве аргумента объекта в список или множество. Аргументом может быть Iterable , Sequence , или Array . Типы объекта-получателя и аргумента могут быть разными, например, вы можете добавить все элементы из Set в List .

При вызове к списку addAll() добавляет новые элементы в том же порядке, в котором они находятся в коллекции-аргументе. Вы также можете передать addAll() позицию, в которую будет вставлен первый элемент из коллекции-аргумента. За ним последуют другие элементы из коллекции-аргумента, сдвигая элементы коллекции-получателя в конец.

fun main() < val numbers = mutableListOf(1, 2, 5, 6) numbers.addAll(arrayOf(7, 8)) println(numbers) // [1, 2, 5, 6, 7, 8] numbers.addAll(2, setOf(3, 4)) println(numbers) // [1, 2, 3, 4, 5, 6, 7, 8] >

Вы также можете добавлять элементы, используя in-place версию оператора plus — plusAssign ( += ). При применении к изменяемой коллекции += добавляет второй операнд (элемент или другую коллекцию) в конец коллекции.

fun main() < val numbers = mutableListOf("one", "two") numbers += "three" println(numbers) // [one, two, three] numbers += listOf("four", "five") println(numbers) // [one, two, three, four, five] >

Удаление элементов

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

fun main() < val numbers = mutableListOf(1, 2, 3, 4, 3) numbers.remove(3) // удаляет только первое значение `3` println(numbers) // [1, 2, 4, 3] numbers.remove(5) // ничего не удаляет println(numbers) // [1, 2, 4, 3] >

Для одновременного удаления нескольких элементов существуют следующие функции:

  • removeAll() — удаляет все элементы, присутствующие в коллекции-аргументе. В качестве альтернативы вы можете вызвать её с предикатом; в этом случае функция удаляет все элементы, для которых предикат возвращает true .
  • retainAll() — противоположность removeAll() : удаляет все элементы кроме тех, что находятся в коллекции-аргументе. При использовании с предикатом она оставляет только те элементы, которые ему соответствуют.
  • clear() — удаляет все элементы из списка, оставляя его пустым.
fun main() < val numbers = mutableListOf(1, 2, 3, 4) println(numbers) // [1, 2, 3, 4] numbers.retainAll < it >= 3 > println(numbers) // [3, 4] numbers.clear() println(numbers) // [] val numbersSet = mutableSetOf("one", "two", "three", "four") numbersSet.removeAll(setOf("one", "two")) println(numbersSet) // [three, four] > 

Еще один способ для удаления элементов из коллекции — оператор minusAssign ( -= ) — это in-place версия оператора minus . Второй аргумент может быть либо одним элементом, либо другой коллекцией. Если второй аргумент — это элемент, то оператор -= удалит первое вхождение этого элемента. Если же второй аргумент — это коллекция, то будут удалены все вхождения её элементов. Например, если список содержит повторяющиеся элементы, то они все будут удалены. Второй операнд может содержать элементы, которых нет в коллекции. Такие элементы не влияют на выполнение операции.

fun main() < val numbers = mutableListOf("one", "two", "three", "three", "four") numbers -= "three" println(numbers) // [one, two, three, four] numbers -= listOf("four", "five") //numbers -= listOf("four") // делает то же самое, что и выше println(numbers) // [one, two, three] >

Обновление элементов

Списки и ассоциативные списки также предоставляют операции для обновления элементов. Они описаны в разделах List: специфичные операции и Map: специфичные операции. Для Set обновление элементов не имеет смысла, поскольку фактически он удаляет элемент и добавляет другой.

© 2015—2023 Open Source Community

Массивы

Рассмотрим работу с массивами в Kotlin, которые являются классами.

Массив можно создать двумя способами — через конструктор Array() или через методы arrayOf(), arrayOfNulls(), emptyArray().

arrayOf()

Создадим массив и получим значение третьего элемента.

 val myArray = arrayOf(1, 2, 3, 4, 5) println(myArray[2]) 

Узнать длину массива можно при помощи свойства size.

 println(myArray.size) // 5 

А что случится, если мы добавим в массив строки?

 val myArray = arrayOf(1, 2, 3, 4, 5, "зайчик", "вышел", "погулять") println(myArray[5]) 

Ничего страшного, у нас получился массив смешанного типа. Всё работает, ничего не ломается.

Если мы хотим строгого поведения и не хотим смешивать разные типы, то используем обобщения.

 val myArray = arrayOf(1, 2, 3, 4, 5) // только числа Integer 

Существует также синонимы метода, когда уже в имени содержится подсказка: intArrayOf(), harArrayOf(), booleanArrayOf(), longArrayOf(), shortArrayOf(), byteArrayOf().

 val myArray = intArrayOf(1, 2, 3, 4, 5) 

Пройтись по элементам массива и узнать значение индекса можно с помощью метода withIndex():

 val numbersArray = intArrayOf(1, 2, 3, 4, 5) for ((index, value) in numbersArray.withIndex())

Свойство indices

У массива есть свойство indices и мы можем переписать пример по другому.

 val numbers = intArrayOf(1, 2, 3, 4, 5) for (index in numbers.indices) < println("Значение индекса $index равно $") > 

Свойство возвращает интервал Range, который содержит все индексы массива. Это позволяет не выйти за пределы массива и избежать ошибки ArrayIndexOutOfBoundsException.

Но у свойства есть очень интересная особенность. Взгляните на код:

 val numbers = intArrayOf(1, 2, 3, 4, 5) for(index in numbers.indices - 2) < println(numbers[index]) >// 1 2 4 5 

Из интервала индексов массива мы убрали третий элемент (отсчёт от 0). И теперь при выводе элементов массива мы не увидим числа 3.

Можно сложить два массива.

 val numbers = intArrayOf(1, 2, 3) val numbers3 = intArrayOf(4, 5, 6) val foo2 = numbers3 + numbers println(foo2[5]) // 3 

arrayOfNulls()

Для создания массива с заполненными значениями null можно использовать отдельную функцию arrayOfNulls().

Создадим массив с тремя элементами.

 val array = arrayOfNulls(3) // [null, null, null] // равносильно // arrayOf(null, null, null) 

Присвоим значения пустым элементам.

 var arr2 = arrayOfNulls(2) arr2.set(0, "1") arr2.set(1, "2") // или arr2[0] = "1" arr2[1] = "2" // получить значения println(arr2[0]) // или arr2.get(0) println(arr2[1]) 

emptyArray()

Создадим пустой массив и заполним его данными.

 var arr = emptyArray() arr += "1" arr += "2" arr += "3" arr += "4" arr += "5" 

val vs var

Нужно уяснить разницу между var и val при работе с массивами.

 // Создали новый массив var myArray = arrayOf(1, 2, 3) // Это совершенно новый массив myArray = arrayOf(4, 5) 

Фактически мы уничтожили первый массив и создали вместо него второй массив.

Если мы попытаем написать такой же код с использованием val, то компилятор запретит такое действие.

 // Создали новый массив val myArray = arrayOf(1, 2, 3) // Нельзя. Компилятор не пропустит myArray = arrayOf(4, 5) 

Но при этом вы можете менять значения элементов массива, созданного через val.

 val myArray = arrayOf(1, 2) myArray[0] = 3 // меняем первый элемент массива myArray[1] = 4 // меняем второй элемент массива 

Конструктор Array()

При использовании конструктора нужно указать размер массива в первом параметре и лямбда-выражение во втором.

 val myArray = Array(5, < i ->i * 2 >) println(myArray[3]) 

Мы задали пять элементов и каждый элемент в цикле умножаем на 2. В итоге получим массив чисел 0, 2, 4, 6, 8.

Создадим массив строк от «A» до «Z»

 val letters = Array(26) < i ->('A' + i).toString() > println(letters.joinToString("")) 

Лямбда-выражение принимает индекс элемента массива и возвращает значение, которое будет помещено в массив с этим индексом. Значение вычисляется путём сложения индекса с кодом символа и преобразованием результата в строку.

Можно опустить тип массива и написать Array(26), компилятор самостоятельно определит нужный тип.

Есть отдельные классы для каждого примитивного типа — IntArray, ByteArray, CharArray и т.д.

 val zeros = IntArray(3) // первый способ val zeros = intArrayOf(0, 0, 0) // второй способ при помощи фабричного метода println(zeros.joinToString()) 

Можно использовать лямбда-выражение.

 val intArray = IntArray(4) i + i> println(intArray.joinToString()) 

Класс Arrays

Для вывода значений массива используйте класс Arrays с методом toString(), который вернёт результат в удобном и читаемом виде. Сейчас в Kotlin появилась функция contentToString(), которая является предпочтительным вариантом.

 println(Arrays.toString(arr)) // старый способ println(arr.contentToString()) // рекомендуемый способ 

Перебор элементов массива

Обычный перебор через for.

 val arr = arrayOf(1, 2, 3, 4, 5) for (i in arr)

Можно одной строкой через forEach.

 arr.forEach < i ->println("Значение элемента равно $i") > 

Если нужна информация не только о значении элемента, но и его индексе, то используем forEachIndexed.

 arr.forEachIndexed < index, element ->println("$index : $element") > // Результат 0 : 1 1 : 2 2 : 3 3 : 4 4 : 5 

Перевернуть массив: reversedArray()

Для операции создадим дополнительную переменную для нового массива с перевёрнутыми значениями. Оригинал останется без изменений.

 val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9) var reversedArray = numbers.reversedArray() println(Arrays.toString(reversedArray)) 

Перевернуть массив: reverse()

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

 val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9) numbers.reverse() println(Arrays.toString(numbers)) 

Сортировка элементов массива

В Kotlin очень просто сортировать элементы.

Вызываем метод sort(). Мы меняем существующий массив, а не создаём новый.

 val numbers: IntArray = intArrayOf(7, 5, 8, 4, 9, 6, 1, 3, 2) numbers.sort() // println(Arrays.toString(numbers)) // старый способ println("Sorted array: $") 

Сортировать можно не весь массив, а только определённый диапазон. Указываем начало и размер диапазона. Допустим, нам нужно отсортировать только первые три элемента из предыдущего примера.

 numbers.sort(0, 3) // 5, 7, 8, 4, 9, 6, 1, 3, 2 

Сортировка в обратном порядке от наибольшего значения к наименьшему.

 numbers.sortDescending() 

Если нужно сохранить исходный массив, то вызываем другие функции, которые создадут новый массив.

 val numbers: IntArray = intArrayOf(7, 5, 8, 4, 9, 6, 1, 3, 2) val sortedNumbers: IntArray = numbers.sortedArray() // новый сортированный массив val descendingSortedNumber: IntArray = numbers.sortedArrayDescending() // новый сортированный массив в обратном порядке println("Original array $:Sorted array $") // Original array [7, 5, 8, 4, 9, 6, 1, 3, 2]:Sorted array [1, 2, 3, 4, 5, 6, 7, 8, 9] 

Для сортировки объектов указываем компаратор и условие сравнения. Например, мы хотим сравнить котов по их возрастам.

 val cats = arrayOf(Cat("Барсик", 8), Cat("Мурзик", 4), Cat("Васька", 9)) // массив до сортировки cats.forEach < println(it) >// сортируем по возрасту cats.sortWith(Comparator < c1: Cat, c2: Cat ->c1.age - c2.age >) cats.forEach < println(it) >data class Cat(val name: String, val age: Int) 

Вместо компаратора можно использовать функцию sortBy() с указанием условия. Сравним теперь котов не по возрасту, а по их именам.

 val cats = arrayOf(Cat("Барсик", 8), Cat("Мурзик", 4), Cat("Васька", 9)) cats.forEach < println(it) >cats.sortBy < cat ->cat.name > cats.forEach < println(it) >data class Cat(val name: String, val age: Int) 

Содержится ли элемент в массиве

Если содержится, то возвращает true.

 val array = arrayOf(1, 2, 3, 4, 5) val isContains = array.contains(9) println(isContains) // false 

Найти среднее значение чисел в массиве

Используем функцию average(). Возвращается Double.

 val array = arrayOf(1, 3, 5) println(array.average()) // 3.0 

Подсчитать сумму чисел в массиве

 val array = arrayOf(1, 2, 3, 4, 5) println(array.sum()) // 15 

Найти наибольшее и наименьшее число в массиве

В цикле сравниваем каждое число с эталоном, которые вначале принимает значение первого элемента. Если следующее число массива больше эталона, то берём его значение. В итоге после перебора получим наибольшее число в массиве.

 val numbers: IntArray = intArrayOf(4, 9, 3, 2, 6) var largestElement = numbers[0] for (number in numbers) < if(largestElement < number) largestElement = number >println("Наибольшее число в массиве: $largestElement") 

Но можно не писать свой код, а вызвать готовые функции min() и max().

 println(numbers.min()) println(numbers.max()) 

Функция intersect(): найти общие элементы двух массивов

Есть два массива с числами. Нужно сравнить их и найти у них общие числа. Поможет нам функция intersect()

 val firstArray = arrayOf(1, 2, 3, 4, 5) val secondArray = arrayOf(3, 5, 6, 7, 8) val intersectedArray = firstArray.intersect(secondArray.toList()).toIntArray() println(Arrays.toString(intersectedArray)) //[3, 5] 

Выбрать случайную строку из массива

Имеется массив строк. Сначала вычисляем размер массива. Затем генерируем случайное число в диапазоне от 0 до (почти) 1, которое умножаем на количество элементов в массиве. После этого результат преобразуется в целое число вызовом toInt(). Получается выражение типа 0.811948208873101 * 5 = 4. В Kotlin есть свой класс Random, поэтому случайное число можно получить другим способом.

 val cats = arrayOf("Барсик", "Мурзик", "Васька", "Рыжик", "Персик") val arraySize = cats.size // Java-style val rand = (Math.random() * arraySize).toInt() val name = "$>" println(name) // Kotlin-style val rand = Random.nextInt(arraySize) val name = "$" println(name) 

По этому принципу можно создать игру «Камень, Ножницы, Бумага».

 private fun getChoice(optionsParam: Array) = optionsParam[Random.nextInt(optionsParam.size)] val options = arrayOf("Камень", "Ножницы", "Бумага") val choice = getChoice(options) println(choice) 

shuffle(): Перемешать элементы (Kotlin 1.40)

Перемешать элементы массива в случайном порядке можно при помощи метода shuffle().

 val numbers = arrayOf(1, 2, 3, 4, 5) numbers.shuffle() println(numbers.contentToString()) 

onEach(): Операция с каждым элементом массива по очереди (Kotlin 1.40)

В коллекциях мы можем пройтись по всем элементам и что-то с каждым сделать. Теперь такое возможно и с элементами массива. Пройдёмся по всем числам массива, удвоим каждое число и конвертируем в строку.

 var str = "" val numbers = arrayOf(1, 2, 3, 4, 5) numbers.onEach println(str) 

Удалить дубликаты

Удалить дубликаты можно несколькими способами. Например, через toSet()

 val myArray = arrayOf(1, 1, 2, 3, 4, 5, 5, 4, 3, 2) println(myArray.toSet().joinToString()) 

Мы получим множество, которое не допускает дубликатов. Порядок элементов сохраняется. Обратно в массив можно преобразовать через toIntArray() или схожие функции.

Аналогично можно использовать toHashSet(), получив HashSet, который тоже не допускает дубликатов, но не гарантирует очерёдность элементов.

Другой вариант — toMutableSet(). Порядок сохранится.

Самый простой вариант — вызвать функцию distinct(), который вернёт новый массив без дубликатов.

 val myArray = arrayOf(1, 1, 2, 3, 4, 5, 5, 4, 3, 2) println(myArray.joinToString()) val newArray = myArray.distinct() println(newArray.joinToString()) 

Двумерные массивы

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

Двумерный массив — это массив, который содержит другие массивы. Создадим двумерный массив 5х5 и заполним его нулями.

 // Создаём двумерный массив var cinema = arrayOf>() // заполняем нулями for (i in 0..4) < var array = arrayOf() for (j in 0..4) < array += 0 >cinema += array > // выводим данные массива for (array in cinema) < for (value in array) < print("$value ") >println() > // Результат 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 

Сейчас в кинотеатре пусто. Первый зритель берёт билет в центре зала.

 // центр зала cinema[2][2] = 1 // три места во втором ряду for (i in 1..3) < cinema[3][i] = 1 >// весь первый ряд for (i in 0..4) < cinema[4][i] = 1 >// выводим данные массива for (array in cinema) < for (value in array) < print("$value ") >println() > // Результат 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 0 1 1 1 1 1 

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

 var rubikCube = arrayOf>>() for (i in 0..2) < var piece = arrayOf>() for (j in 0..2) < var array = arrayOf() for (k in 0..2) < array += 0 >piece += array > rubikCube += piece > // второй слой, третий ряд, первое место rubikCube[1][2][0] = 1 println(Arrays.deepToString(rubikCube)) // Результат 0, 0, 0 | 0, 0, 0 | 0, 0, 0 0, 0, 0 | 0, 0, 0 | 0, 0, 0 0, 0, 0 | 1, 0, 0 | 0, 0, 0 

Массивы как тип данных

Массив можно представить как сгруппированные вместе данные одного типа. При этом заранее известно количество этих данных-элементов, а также у каждого элемента есть свое место в массиве. На рисунке ниже показан пример одного массива, элементами которого являются целые числа. Каждое число лежит в своей ячейке, а над ячейкой написан ее номер – индекс элемента.

Пример ячеек массива и их индексации

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

В языке программирования Kotlin тип данных «массив» обозначается словом Array . Объявление переменных этого типа ничем не отличается от объявления переменных ранее нами изученных, за исключением того, что дополнительно указывается тип элементов массива. Это делается в угловых скобках после слова Array .

Объявление массива в Kotlin

Примеры объявления массивов разных типов:

fun main() { val a: ArrayInt>; val b: ArrayString>; val c: ArrayDouble>; }

Здесь массив a предназначен для хранения целых чисел, b – строк, c – вещественных чисел.

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

Создание массивов функцией arrayOf()

Самый простой способ инициировать значением переменную типа Array – это вызвать встроенную в Kotlin функцию arrayOf() , которой в скобках передать через запятую элементы массива. Функция сама посчитает их количество, которое потом мы можем узнать через свойство массива size .

fun main() { val a: ArrayDouble> = arrayOf(1.0, 1.3, -1.2) val s: Int = a.size var i = 0 while (i  s) { println(a[i]) i++ } }

Как определить размер массива в Kotlin - свойство size

В программе на экран выводятся значения элементов массива. К ним мы обращаемся по индексу, который указывается в квадратных скобках после имени массива. В данном случае в цикле переменная i , которой мы назначили роль индекса, принимает значения 0, 1 и 2. Когда i становится равна трем, цикл завершает свою работу, потому что выражение 3 < 3 возвращает ложь ( i равна трем и s равна трем).

С помощью квадратных скобок можно не только извлекать значение из массива (на самом деле оно не извлекается, а остается там, мы просто его «берем и смотрим»), но и менять значение в ячейке, обращаясь к ней по индексу. Если после обращения к элементу массива стоит знак присвоения, значит элемент не извлекается, а перезаписывается.

fun main() { val a: ArrayDouble> = arrayOf(1.0, 1.3, -1.2) a[1] = 2.8 a[0] = a[2] * 2 println(a[0]) println(a[1]) println(a[2]) }

Обратите внимание, что массив объявлен как неизменяемый – через val . Однако это не мешает нам изменять значение его элементов. На самом деле переменная действительно остается неизменяемой. Ей нельзя присвоить другой массив. Но в самом массиве менять элементы можно.

Заполним массив случайными числами:

import kotlin.random.Random fun main() { val a: ArrayInt> = arrayOf(0, 0, 0, 0, 0) var i = 0 while (i  a.size) { a[i] = Random.nextInt(10) print(a[i]) print(" ") i++ } }

Заполнение массива случайными числами в Kotlin

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

Есть другой способ создания массива – путем вызова класса Array . Как уже было сказано, типы данных это и есть классы данных. В Kotlin имя класса, упомянутое после знака присваивания, означает вызов конструктора этого класса. Конструктор создает объект этого типа, то есть экземпляр класса.

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

val a: ArrayInt> = Array(5, {0})

Создание массива вызовом конструктора класса Array

В Kotlin такой лямбда-аргумент функции принято выносить за скобку:

val a: ArrayInt> = Array(5) {0}

На скрине вместо цикла while используется цикл for , особенности работы которого мы рассмотрим в следующем уроке.

Практическая работа:

  1. Заполните массив строками, которые пользователь вводит с клавиатуры и затем выведите их на экран в обратном порядке.
  2. Заполните массив случайными целыми числами. Найдите элементы с максимальным и минимальным значением, используя функции-методы массива min() и max() .

X Скрыть Наверх

Kotlin с нуля. Курс для начинающих

Как добавить элемент в массив kotlin

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

При определении массива после типа Array в угловых скобках необходимо указать, объекты какого типа могут храниться в массиве. Например, определим массив целых чисел:

val numbers: Array

С помощью встроенной функции arrayOf() можно передать набор значений, которые будут составлять массив:

val numbers: Array = arrayOf(1, 2, 3, 4, 5)

То есть в данном случае в массиве 5 чисел от 1 до 5.

С помощью индексов мы можем обратиться к определенному элементу в массиве. Индексация начинается с нуля, то есть первый элемент будет иметь индекс 0. Индекс указывается в квадратных скобках:

val numbers: Array = arrayOf(1, 2, 3, 4, 5) val n = numbers[1] // получаем второй элемент n=2 numbers[2] = 7 // переустанавливаем третий элемент println("numbers[2] = $") // numbers[2] = 7

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

val numbers = Array(3, ) // [5, 5, 5]

Здесь применяется конструктор класса Array. В этот конструктор передаются два параметра. Первый параметр указывает, сколько элементов будет в массиве. В данном случае 3 элемента. Второй параметр представляет выражение, которое генерирует элементы массива. Оно заключается в фигурные скобки. В данном случае в фигурных скобках стоит число 5, то есть все элементы массива будут представлять число 5. Таким образом, массив будет состоять из трех пятерок.

Но выражение, которое создает элементы массива, может быть и более сложным. Например:

var i = 1; val numbers = Array(3, < i++ * 2>) // [2, 4, 6]

В данном случае элемент массива является результатом умножения переменной i на 2. При этом при каждом обращении к переменой i ее значение увеличивается на единицу.

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

Для перебора массивов можно применять цикл for :

fun main() < val numbers = arrayOf(1, 2, 3, 4, 5) for(number in numbers)< print("$number \t") >>

В данном случае переменная numbers представляет массив чисел. При переборе этого массива в цикле каждый его элемент оказывается в переменной number , значение которой, к примеру, можно вывести на консоль. Консольный вывод программы:

1 2 3 4 5

Подобным образом можно перебирать массивы и других типов:

fun main() < val people = arrayOf("Tom", "Sam", "Bob") for(person in people)< print("$person \t") >>

Консольный вывод программы:

Tom Sam Bob

Можно применять и другие типы циклов для перебора массива. Например, используем цикл while :

fun main() < val people = arrayOf("Tom", "Sam", "Bob") var i = 0 while( i in people.indices)< println(people[i]) i++; >>

Здесь определена дополнительная переменная i , которая представляет индекс элемента массива. У массива есть специальное свойство indices , которое содержит набор всех индексов. А выражение i in people.indices возвращает true, если значение переменной i входит в набор индексов массива.

В самом цикле по индексу обащаемся к элементу массива: println(people[i]) . И затем переходим к следующему индексу, увеличивая счетчик: i++ .

То же самое мы могли написать с помощью цикла for:

for (i in people.indices)

Проверка наличия элемента в массиве

Как и в случае с последовательностью мы можем проверить наличие или отсутствие элементов в массиве с помощью операторов in и !in :

val numbers: Array = arrayOf(1, 2, 3, 4, 5) println(4 in numbers) // true println(2 !in numbers) // false

Массивы для базовых типов

Для упрощения создания массива в Kotlin определены дополнительные типы BooleanArray , ByteArray , ShortArray , IntArray , LongArray , CharArray , FloatArray и DoubleArray , которые позволяют создавать массивы для определенных типов. Например, тип IntArray позволяет определить массив объектов Int , а DoubleArray — массив объектов Double :

val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5) val doubles: DoubleArray = doubleArrayOf(2.4, 4.5, 1.2)

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

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

val numbers = IntArray(3, ) val doubles = DoubleArray(3, )

Двухмерные массивы

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

Определение двухмерных массивов менее интуитивно понятно и может вызывать сложности. Например, двухмерный массив чисел:

val table: Array> = Array(3, < Array(5, ) >)

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

Используя индексы, можно обращаться к подмассивам в подобном массиве, в том числе переустанавливать их значения:

val table = Array(3, < Array(3, ) >) table[0] = arrayOf(1, 2, 3) // первая строка таблицы table[1] = arrayOf(4, 5, 6) // вторая строка таблицы table[2] = arrayOf(7, 8, 9) // третья строка таблицы

Для обращения к элементам подмассивов двухмерного массива необходимы два индекса. По первому индексу идет получение строки, а по второму индексу — столбца в рамках этой строки:

val table = Array(3, < Array(3, ) >) table[0][1] = 6 // второй элемент первой строки val n = table[0][1] // n = 6

Используя два цикла, можно перебирать двухмерные массивы:

fun main() < val table: Array> = Array(3, < Array(3, ) >) table[0] = arrayOf(1, 2, 3) table[1] = arrayOf(4, 5, 6) table[2] = arrayOf(7, 8, 9) for(row in table) < for(cell in row)< print("$cell \t") >println() > >

С помощью внешнего цикла for(row in table) пробегаемся по всем элементам двухмерного массива, то есть по строкам таблицы. Каждый из элементов двухмерного массива сам представляет массив, поэтому мы можем пробежаться по этому массиву и получить из него непосредственно те значения, которые в нем хранятся. В итоге на консоль будет выведено следующее:

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *