Подобно другим языкам программирования, массивы в Kotlin предоставляют возможность хранить и управлять упорядоченной коллекцией элементов одного и того же типа данных, например списком чисел, символов или объектов. Они обеспечивают структурированное и организованное хранение данных, а также эффективный доступ к отдельным элементам через индекс. Массивы используются во многих случаях: от простых списков и таблиц до более сложных многомерных структур данных. В Котлине массивы — это объекты, имеющие специально разработанный тип данных. массив иметь.
Основные свойства массивов в Котлине:
Тот же тип данных включенных элементов: Это означает, что все объекты в массиве должны иметь один и тот же тип данных. Например просто Int, строка или двойной и т. д., например, сочетание Int и строка приведет к ошибке программы.
Чтобы указать тип данных для элементов массива, тип содержащихся объектов указывается в угловых скобках после типа массива при объявлении массива. В следующем примере создается массив Int-Созданные ценности:
val arrayOfNumbers: Array<Int> // 'arrayOfNumbers' ist Variablenname. 'Array' ist Datentyp der Variable. '<Int>' bedeutet, dass das Array ausschließlich Werte des Datentyps 'Int' speichern kann.
Следующим шагом будет использование встроенной функции массивOf() ряд Int-передача значений в массив:
val arrayOfNumbers: Array<Int> = arrayOf(1, 2, 3, 4, 5) // Es wird ein Array mit dem Namen 'arrayOfNumbers' vom Typ 'Array<Int>' deklariert und gleichzeitig mit Hilfe der Funktion 'arrayOf()' mit den Int-Werten 1, 2, 3, 4 und 5 initialisiert.
val arrayOfNumbers2: Array<Int> = arrayOf(1, 2, 3, 4, "Tom") // Der Versuch, ein Element vom Typ String hinzuzufügen, führt zu einem Fehler.
Индексированные элементы: Элементы массива индексируются, то есть они имеют определенную позицию в массиве, к которой можно получить доступ через связанный индекс. Индексирование массивов начинается с 0, т.е. первый элемент имеет индекс 0, второй элемент индекс 1, третий индекс 2 и т.д. Индекс дается в квадратных скобках. Давайте посмотрим на наш предыдущий пример:
fun main() {
val arrayOfNumbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
println(arrayOfNumbers[0]) // Hier wird der Wert des Elements mit Index '0' ausgegeben, also '1'.
println(arrayOfNumbers[1]) // 2
println(arrayOfNumbers[4]) // 5
arrayOfNumbers[0] = 44 // Element mit Index '0' wird geändert von '1' auf '44'
println(arrayOfNumbers[0]) // 22
}
Исправленный размер: Массивы имеют фиксированный размер, который задается при их создании. После создания размер массива нельзя изменить. В приведенном ниже примере мы пытаемся добавить дополнительный элемент с индексом 5 добавить в массив:
fun main() {
val arrayOfNumbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
arrayOfNumbers[5] = 66 // Anweisung, um ein Element mit Index '5' und mit dem Wert '66' dem Array 'arrayOfNumbers' hinzufügen.
// Es wird Fehler 'Index 5 out of bounds for length 5' ausgegeben, da die Größe eines Arrays nicht verändert werden darf.
println(arrayOfNumbers[5])
}
Чтобы создать массив в Котлине, вы также можете использовать Конструктор класса Array use, который принимает два параметра. Первый параметр определяет размер массива, а второй параметр определяет размер. Инициализация лямбда содержит. Лямбда инициализации — это выражение, которое выполняется для каждого элемента массива и вычисляет начальное значение для этого элемента.
fun main() {
val arrayOfNumbers: Array<Int> = Array(3, {2*5}) // Parameter '3' definiert die Arraygröße, also das Array hat 3 Elemente.
// Der Ausdruck '{2*5}' wird für jedes Element des Arrays ausgeführt.
// Somit besteht das Array aus 3 Elementen mit dem Wert '10' [10. 10. 10].
for (element in arrayOfNumbers) {
println(element) // 10, 10, 10
}
}
Das Инициализация лямбда также может содержать более сложные выражения и, следовательно, выполнять более сложные вычисления.
fun main() {
var i:Int = 1
val arrayOfNumbers: Array<Int> = Array(5, {i++ * 2})
for (element in arrayOfNumbers) {
println(element) // 2, 4, 6, 8, 10
}
}
Перебор массивов в Котлине
В Kotlin вы можете перебирать массивы и получать доступ к их элементам различными способами. Одна из возможностей - иметь один для цикла использовать. Пример:
fun main() {
val arrayOfNames: Array<String> = arrayOf("Tom", "Jerry", "Anna", "Frank", "Mandy")
for (name in arrayOfNames) {
println(name)
}
}
Другая возможность – в рамках для цикла использовать индекс в качестве текущей переменной для перебора элементов массива один за другим.
fun main() {
val arrayOfNames: Array<String> = arrayOf("Tom", "Jerry", "Anna", "Frank", "Mandy")
for (i in arrayOfNames.indices) {
println("Name at index $i is ${arrayOfNames[i]}")
}
}
Тонкой альтернативой является использование функция forEach(), который выполняет действие над каждым элементом массива.
fun main() {
val arrayOfNumbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
arrayOfNumbers.forEach { println(it) }
}
Die Funktion Foreach выводит указанное лямбда-выражение (лямбда-функция) для каждого элемента массива, передавая каждый элемент в качестве аргумента лямбда-выражению. Слово it в функции Lambda представляет текущий элемент, к которому применяется действие внутри функции.
Комментарий: Ключевое слово it В Котлине это неявное имя отдельного параметра в лямбда-функции. Если лямбда-функция имеет один параметр, имя параметра можно опустить и вместо него указать неявное. it .
Проверить, существует ли элемент в массиве
Предположим, у нас есть задача проверить массив на наличие имени "Джерри" Проверять. У нас есть два варианта для этого. Вариант номер 1 – использовать в операторах:
fun main() {
val arrayOfNames: Array<String> = arrayOf("Tom", "Jerry", "Anna", "Frank", "Mandy")
if ("Jerry" in arrayOfNames) {
println("The name 'Jerry' is included")
} else {
println("The name 'Jerry' is not included")
}
}
Также можно использовать цикл для перебора всех элементов массива один за другим и проверки, соответствует ли каждый элемент искомому элементу. Пример:
fun main() {
val arrayOfNames: Array<String> = arrayOf("Tom", "Jerry", "Anna", "Frank", "Mandy")
for (name in arrayOfNames) {
if (name == "Jerry") {
println("The name 'Jerry' is included")
break
}
}
}
Специальные функции для инициализации массивов примитивных типов данных
В Котлине для каждого примитивного типа данных существует специальный тип массива. К ним относятся BooleanArray, ByteArray, ShortArray, IntArray, LongArray, CharArray, FloatArray и ДаблМассив. Эти специальные типы массивов позволяют создавать массивы для соответствующего типа данных, что упрощает обработку и обработку данных.
val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5) // Initialisierung des Arrays namens 'intArray' mithilfe der Funktion intArrayOf() und mit festzugewiesenen Int-Werten 1, 2, 3, 4, 5
val longArray: LongArray = longArrayOf(1L, 2L, 3L)
val floatArray: FloatArray = floatArrayOf(1.0f, 2.0f, 3.0f)
val doubleArray: DoubleArray = doubleArrayOf(1.0, 2.0, 3.0)
val charArray: CharArray = charArrayOf('a', 'b', 'c')
val booleanArray: BooleanArray = booleanArrayOf(true, false, true)
Инициализацию этих массивов можно выполнить либо путем явного присвоения значений, как в примерах выше, либо с помощью конструкторов, определенных для конкретных типов массивов.
val intArray = IntArray(7) // Int-Array mit der Länge '7' und dem Standardwert '0'
val longArray = LongArray(3) // Long-Array mit der Länge '3' und dem Standardwert '0'
val floatArray = FloatArray(2) // Float-Array mit der Länge '2' und dem Standardwert '0.0'
val doubleArray = DoubleArray(4) // Double-Array mit der Länge '4' und dem Standardwert '0.0'
val charArray = CharArray(6) // Char-Array mit der Länge '6' und dem Standardwert '\u0000'
val booleanArray = BooleanArray(3) // Boolean-Array mit der Länge '3' und dem Standardwert 'false'
val intArray = IntArray(7) { -1 } // Int-Array mit der Länge '7' und dem Standardwert '-1'
val longArray = LongArray(3) { 100L } // Long-Array mit der Länge '3' und dem Standardwert '100L'
val floatArray = FloatArray(2) { 1.0f } // Float-Array mit der Länge '2' und dem Standardwert '1.0f'
val doubleArray = DoubleArray(5) { 3.14 } // Double-Array mit der Länge '5' und dem Standardwert '3.14'
val charArray = CharArray(6) { '!' } // Char-Array mit der Länge '6' und dem Standardwert '!'
val booleanArray = BooleanArray(4) { true } // Boolean-Array mit der Länge '4' und dem Standardwert 'true'
Многомерные массивы
Ранее мы рассматривали только одномерные массивы, которые можно рассматривать как последовательность или строку значений.
// Beispiele von eindimesionalen Arrays
val arrayOfIntegers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
val arrayOfNames: Array<String> = arrayOf("Tom", "Max", "Anna", "Jerry", "Jack")
Однако существует несколько вариантов использования при разработке программного обеспечения, которые требуют представления и обработки более сложных, многомерных структур данных. Некоторые из наиболее распространенных и известных сценариев использования для организации многомерных данных: сопоставление таблиц и матриц с числами для выполнения вычислений или представление значений пикселей на изображениях, а также значений объема в 3D-моделях. Хранить и обрабатывать такие структуры данных в Котлине многомерные массивы verwendet.
Многомерные массивы в Kotlin — это структуры данных, состоящие из вложенных массивов, которые организуют данные по нескольким измерениям или уровням. Их можно рассматривать как массивы массивов.
Например, двумерный массив (2D-массив) похож на таблицу, в которой данные расположены по строкам и столбцам.
fun main() {
// Erstellt ein 2D-Array mit 3 Zeilen und 3 Spalten mit Initialwerten '0'
val matrix = Array(3) { Array(3) { 0 } }
// Füllt das Array mit Werten
matrix[0] = arrayOf(1, 2, 3)
matrix[1] = arrayOf(4, 5, 6)
matrix[2] = arrayOf(7, 8, 9)
// Um auf die Elemente von Unterarrays in einem zweidimensionalen Array zuzugreifen,
// sind zwei Indizes erforderlich. Mit dem ersten Index wird die Zeile abgerufen und
// mit dem zweiten Index die Spalte innerhalb dieser Zeile.
val number1 = matrix[1][2] // Zeile mit Index '1', Spalte mit Index '2'
println(number1) // Ausgabe '6'
val number2 = matrix[2][0] // Zeile mit Index '1', Spalte mit Index '2'
println(number2) // Ausgabe '7'
}
Также возможно перебирать двумерные массивы, используя два вложенных цикла.
fun main() {
// Erstellt ein 2D-Array mit 3 Zeilen und 3 Spalten mit Initialwerten '0'
val matrix = Array(3) { Array(3) { 0 } }
// Füllt das Array mit Werten
matrix[0] = arrayOf(1, 2, 3)
matrix[1] = arrayOf(4, 5, 6)
matrix[2] = arrayOf(7, 8, 9)
// Gibt das Array aus
for (row in matrix) {
for (value in row) {
print("$value ")
}
println()
}
}
Трехмерный массив (3D-массив) похож на стопку таблиц друг на друге и может быть создан путем вложения массива 2D-массивов.
fun main() {
// Erstellt ein 3D-Array mit 2 Schichten, 3 Zeilen und 3 Spalten
val array3D = Array(2) { Array(3) { Array(3) { 0 } } }
// Füllt das 3D-Array mit Werten
array3D[0] = arrayOf(
arrayOf(1, 2, 3),
arrayOf(4, 5, 6),
arrayOf(7, 8, 9)
)
array3D[1] = arrayOf(
arrayOf(10, 11, 12),
arrayOf(13, 14, 15),
arrayOf(16, 17, 18)
)
// Um auf die Elemente von Unterarrays in einem dreidimensionalen Array zuzugreifen,
// sind drei Indizes erforderlich. Mit dem ersten Index wird das Array angesprochen,
// mit dem zweiten Index die Zeile innerhalb des Array abgerufen und
// mit dem dritten Index die Spalte innerhalb dieser Zeile.
val number1 = array3D[0][2][0] // Array mit Index '0', Zeile mit Index '2', Spalte mit Index '0'
println(number1) // Ausgabe '7'
val number2 = array3D[1][1][1] // Array mit Index '1', Zeile mit Index '1', Spalte mit Index '1'
println(number2) // Ausgabe '14'
println() // Leere Zeile
// Gibt das 3D-Array aus
for (layer in array3D) {
for (row in layer) {
for (value in row) {
print("$value ")
}
println()
}
println("----")
}
}
В приведенных выше примерах были созданы и заполнены значениями 2D- и 3D-массивы. Обратите внимание, что в этих примерах используются массивы фиксированного размера, но вы также можете использовать ArrayLists для создания динамических многомерных массивов. Мы рассмотрим эту тему подробно позже в уроке.
