Kotlin | Массивы и Списки

Что такое массив (Array).

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

Простыми словами массив это один элемент который в себе содержит определенное количество элементов, обычно одного типа и все эти элементы хранятся на своей позиции. Указывая позицию (индекс) ячейки мы можем получить хранимый элемент с этой ячейки. Представьте себе вагоны поезда, весь поезд с вагонами это массив для хранения чего либо, а вагоны это и есть ячейки массива. В одну ячейку можно записать только один элемент указанного типа. Например если мы объявили что наш массив будет типа Int значит в каждую ячейку можно записать одно целое число. Индекс позиции всегда начинается с позиции 0, это означает что если у нас в массиве есть 3 элемента то индексы ячеек будут таким образом 0, 1, 2.

Мы ознакомились на прошлых уроках с типом данных Float, Boolean, Int и.т.д Так вот, массив хранит набор этих данных, обычно одного типа. По этому когда нам нужно сохранить много разных значений мы не создаем кучу переменных какого либо типа а пользуемся массивами.

Что такое список (List).

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

Как объявить массив.

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

Явное объявление массива:

var array: Array<Int> = arrayOf(5, 6, 9)

В данном примере мы объявляем массив который будет хранить целые числа. Когда мы хотим явно указать тип данных мы пишем тип данных в треугольных скобках <Int>, в данном случае я указал тип данных Int. Для того чтобы явно объявить массив указав тип данных есть и другие способы, вот простой пример как сделать тоже самое:

var array: IntArray = intArrayOf(5, 6, 9)

В данном случае мы использовали уже готовый метод для создания массива с определенным типом данных. Это равнозначно. IntArray возле названия массива можно опустить тогда компилятор сам определит тип данных массива:

var array = intArrayOf(5, 6, 9)

IntArray это класс для хранения массивов примитивного типа Int, есть такие классы для каждого примитивного типа данных: IntArrayByteArrayCharArray и т.д.

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

var array = IntArray(3)

тоже самое используя метод   arrayOf и intArrayOf:

var array1 = intArrayOf(0, 0, 0)
var array2 = arrayOf(0, 0, 0)

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

Если мы создали массив а после решили записать в переменную массива новый массив тогда старый массив полностью сотрется и создастся на его месте новый:

//Создали массив внутри 3 ячейки со значением 0
var array1 = intArrayOf(0, 0, 0)
//Создали новый массив внутри 5 ячеек с разными значениями
//прежний массив сотрется и все данные будут потеряны
array1 = intArrayOf(6, 67, 567, 89, 76)

но если мы укажем val тогда нам уже не даст записать на место старого массива новый:

//Создали массив внутри 3 ячейки со значением 0
val array1 = intArrayOf(0, 0, 0)
//Массив в безопасности, можно перезаписать значения внутри
// но нельзя записать на его место другой массив, выдает ошибку
//подчеркивая красной линией название массива
array1 = intArrayOf(6, 67, 567, 89, 76)

 

Запись и считывание данных.

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

//Создаем массив с 3-мя нолями
val array = intArrayOf(0, 0, 0)
//Записываем на позицию 0 новое значение 43
array[0] = 43
//Теперь в нашем массиве такие значения: (43, 0, 0)

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

//Создаем массив с 3-мя нолями
val array = intArrayOf(56, 6, 12)
//Считываем значение с позиции 1 и записываем
//в переменную testNumber
val testNumber = array[1]
//Теперь в нашей переменной testNumber будет записано значение 6
//так как на позиции 1 у нас в массиве число 6
//помните что в массиве позиции начинаются с 0

Пустые значения:

Мы можем создать массив с пустыми значениями, например null. Для этого используем метод arrayOfNulls:

//Создаем массив с 3-мя начениями null
val arrayNull = arrayOfNulls<Int>(3)
//таким образом у нас будет массив из 3 ячеек
//в каждой из которых значение null
//таким образом (null, null, null)

мы просто указали в треугольных скобках тип данных массива и количество ячеек. Мы также можем создать пустой массив а после в нужный момент его перезаписать и на его место добавить массив с нужными значениями. Для создания пустого массива мы просто пишем emptyArray:

//Создаем пустой массив
var arrayEmpty = emptyArray<String>()
//размер массива равен 0
//когда наам это будет нужно можем перезаписать
//данный массив на новый не пустой массив
arrayEmpty = arrayOf("яблоко", "груша","апельсин")
//Теперь на месте старого массива у нас новый массив
//и он уже не пустой так как содержит 3 элемента

Полезные методы массива:

У массива есть методы которые нам помогают работать с массивом и его содержимым. Один из самых важных методов это размер массива size. Данный метод нам возвращает количество элементов в массиве:

//Создаем массив с 5-ю ячейками
val array = arrayOf(3, 7, 8, 9, 0)
val arraySize = array.size
//Записываем размер массива 5 в переменную arraySize

Есть и другие полезные методы у массива, например reversedArray():

//Создаем массив с 5-ю ячейками: (3, 7, 8, 9, 0)
val arrayOrigin = arrayOf(3, 7, 8, 9, 0)
//Переворачиваем массив записываем перевернутый
//массив в новую переменную reversedArray и теперь
//значения в новом массиве будут на оборот при этом
//старый массив arrayOrigin остается нетронутым
val reversedArray = arrayOrigin.reversedArray()
//Теперь значения в новом массиве выглядят так: (0, 9, 8, 7, 3)

reversedArray() создает новый массив не трогая старый и записывает в новый элементы в перевернутом виде. Если старый массив нам не нужен можно и не создавать новый а перевернуть элементы прямо в оригинальном массиве с помощью reverse():

еще мы можем сортировать элементы в возрастающем порядке с помощью sort():

//Создаем массив с 5-ю ячейками: (3, 7, 8, 9, 0)
val arrayOrigin = arrayOf(3, 7, 8, 9, 0)
//Сортируем оригинальный массив
arrayOrigin.sort()
//Теперь у нас в массиве элементы будут в таком порядке (0, 3, 7, 8, 9)

можно сортировать не весь массив а определенный диапазон:

//Создаем массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
//Сортируем оригинальный массив
arrayOrigin.sort(0, 3)
//В таком случе сортируем только первые 3 числа
//так как мы сортируем от позиции 0 включительно
//до позиции 3 не включительно
//Теперь у нас в массиве элементы будут в таком порядке (3, 5, 9, 1, 0, 67, 11)

Можно сортировать в обратном порядке от большего к меньшему с помощью sortDescending():

//Создаем массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
//Сортируем оригинальный массив от большего к меньшему
arrayOrigin.sortDescending()
//Результат будет такой (67, 11, 9, 5, 3, 1, 0)

Иногда нужно сохранить оригинальный не отсортированный массив а отсортированный записать в другой массив. Для этого можно сделать следующие:

//Создаем массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
//Сортируем оригинал создавая новый отсортированный массив
val sortedArray = arrayOrigin.sortedArray()//От меньшего к большему
val sortedDescendingArray = arrayOrigin.sortedArrayDescending()//От большего к меньшему

Можно проверить содержится указанный элемент в массиве или нет:

//Создаем массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
//Проверяем содержит наш массив число 5 или нет.
//Если содержит то на запишет true в containElement
//если нет то запишет false
val containElement = arrayOrigin.contains(5)

Получить наибольшее и или наименьшее число в массиве:

//Создаем массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
//Проверяем наибольшее число в массиве.
val maxNumber = arrayOrigin.maxOrNull()
//Проверяем наименьшее число в массиве.
val minNumber = arrayOrigin.minOrNull()

Сумма чисел в массиве:

//Создаем массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
//Сумма всех элементов в массиве
val sum = arrayOrigin.sum()

Среднее значение в массиве:

//Создаем массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
//Находим среднее значение в массиве
val average = arrayOrigin.average()

Найти общие элементы в массиве:

//Создаем ервый массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
//Создаем второй массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin2 = arrayOf(1, 34, 7, 45, 56, 675, 3)
//Находим общие элементы, в данном случае это 3 и 1 и создаем новый массив
//в который записываем общие значения для двух массивов
//Нам выдает класс Set по этому мы превращаем результат
//с помощью toIntArray() в массив с типом данных Int
val resultArray = arrayOrigin.intersect(arrayOrigin2.toList()).toIntArray()

Перемешать элементы в массиве:

//Создаем ервый массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
//Перемешиваем массив в случайном порядке
arrayOrigin.shuffle()

 

Списки List<T>, ArrayList<T>

Списки очень похожи на массивы, это почти одно и тоже но есть различия. списки есть с определенным размером который уже нельзя изменить как в случае с массивами такой список называется List, а есть с неопределенным размером которые относятся к типу MutableList, например который мы часто будем использовать ArrayList У списков есть такие же методы которые мы рассмотрели выше. Для сортировки, перемешки, и.т.д у них немного отличаются названия но выполняют туже роль что и в случае массивов только у списков перемешивается всегда не оригинал а копия которую после перемешки нам выдает а оригинал остается нетронутым, Вот простые примеры этих методов:
//Создаем первый массив с 5-ю ячейками: (4, 17, 85, 8, 451)
val arrayOrigin = listOf(4, 17, 85, 8, 45)
//Создаем второй массив с 5-ю ячейками: (4, 10, 85, 8, 4)
val arrayOrigin2 = listOf(4, 10, 85, 8, 4)

val sortedList = arrayOrigin.sorted()
val sumList = arrayOrigin.sum()
val reversedList = arrayOrigin.reversed()
val containsList = arrayOrigin.contains(5)
val minList = arrayOrigin.minOrNull()
val maxList = arrayOrigin.maxOrNull()
val averageList = arrayOrigin.average()
val shuffledList = arrayOrigin.shuffled()
val sortedDescendingList = arrayOrigin.sortedDescending()
val intersection = arrayOrigin.intersect(arrayOrigin2.toList())
все эти функции одинаковы для списков List и ArrayList, отличается только объявление списка. Вот способы явного объявления списка List и не явного, когда компилятор сам определит что за тип данных сохранен в данном списке:
//Создаем список с 5-ю ячейками: (4, 17, 85, 8, 451)
val list1 = listOf(4, 17, 85, 8, 45)
//Создаем список явно указав тип данных с 5-ю ячейками: (4, 17, 85, 8, 451)
val list2:List<Int> = listOf(4, 17, 85, 8, 45)
//Создаем список явно указав тип данных с 5-ю ячейками: (4, 17, 85, 8, 451)
val list3 = listOf<Int>(4, 17, 85, 8, 45)
Для ArrayList явное и не явное объявление списка будет выглядеть так:
//Создаем список с 5-ю ячейками: (4, 17, 85, 8, 451)
val list1 = arrayListOf(4, 17, 85, 8, 45)
//Создаем список явно указав тип данных с 5-ю ячейками: (4, 17, 85, 8, 451)
val list2:ArrayList<Int> = arrayListOf(4, 17, 85, 8, 45)
//Создаем список явно указав тип данных с 5-ю ячейками: (4, 17, 85, 8, 451)
val list3 = arrayListOf<Int>(4, 17, 85, 8, 45)

Разница между List и ArrayList

Вы помните когда мы говорили про массивы мы узнали как можно считывать значения записанные на определенной ячейке и перезаписывать эти значения? Та вот в List тоже можно считывать таким способом значение, но нельзя перезаписать это значение. После создания списка ничего внутри перезаписать больше нельзя, этот список только доступен для чтения:

//Создаем список с 5-ю ячейками: (4, 17, 85, 8, 451)
val list = listOf(4, 17, 85, 8, 45)
//Считываем значение с позиции 2
val number = list[2]
//Пытаемся перезаписать значение
//на позиции 2 но выдает ошибку!
list[2] = 56
//это List нельзя перезаписать значение!

Другое дело ArrayList, мы можем перезаписать, считать данные но также мы можем добавить новые элементы в список так как это не массив и у данного списка размер не определен, можно добавлять новые элементы или удалять элементы которые уже есть:

Мы можем удалить все элементы и можем добавить целый список к уже существующем не удаляя то что уже находиться в списке:

//Создаем список ArrayList с 5-ю ячейками: (4, 17, 85, 8, 451)
val list = arrayListOf(4, 17, 85, 8, 45)
//Считываем значение с позиции 2
val number = list[2]
//Перезаписываем значение на позиции 2
list[2] = 56
//Добавляем еще один элемент в список это число 23
//значения которые добавляем должны быть
// того же типа что и остальные, в данном случае Int
list.add(23)
//Удаляем элемент на позиции 2 теперь нет этой ячейки,
// ее место займет ячейка та что была впереди все равно что стопка книг,
//убрали одну нигу из середины,
//верхние книги займут ее место, тут тоже самое
list.removeAt(2)
//Удаляем все элементы в списке
list.clear()
//Добавляем не по одному элементу а целый список,
//если уже есть элементы в списке то новый список их дополнит не удаляя
list.addAll(listOf(35, 78, 89))
//сли так непонятно то можно тоже самое сделать вот так
val newList = listOf(35, 78, 89)
list.addAll(newList)
//Мы добавили в ArrayList список List
//К уже добваленному списку можно добавить еще один список
//тогда у нас будет один большой список
//чтобы было понятней мы возмем и добавим в наш
//список не список а массив , в таком случае выйдет ошибка,
val arrayTest = intArrayOf(34, 67, 89, 89)
list.addAll(arrayTest)
//Мы можем воспользоваться методом у массива для превращения
//массива в список вот тогда наш список сможет принять наш массив
val arrayTest2 = intArrayOf(34, 67, 89, 89)
list.addAll(arrayTest2.toList())
//Другой вариант просто не указывать что это за массив написав
//просто arrayOf тогда непридется превращать его в List
val arrayTest3 = arrayOf(34, 67, 89, 89)
list.addAll(arrayTest3)

Как вы заметили List только доступен для чтения и нельзя увеличить размер данного списка а вот ArrayList позволяет не только считывать и изменять значения но и добавлять тем самым увеличивая размер списка. Помним что списки медленнее при выполнении чем массивы!

 

6 комментариев для “Kotlin | Массивы и Списки”

  1. Комментарий ко второму массиву “Найти общие элементы массива” надо исправить_)
    //Создаем ервый массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
    val arrayOrigin = arrayOf(9, 3, 5, 1, 0, 67, 11)
    //Создаем второй массив с 7-ю ячейками: (9, 3, 5, 1, 0, 67, 11)
    val arrayOrigin2 = arrayOf(1, 34, 7, 45, 56, 675, 3)

  2. а как можно отсортировать ответ

    плохая оценка семен – 2
    и только потом
    плохая оценка маша – 3
    в смысле уже в самом badArray
    var sortedBadArray = ArrayList()

    if (badArray[1]>badArray[0]) sortedBadArray.sortDescending()

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

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