Verification: a143cc29221c9be0

Php array массив в массиве

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()) {
    println("Значение индекса $index равно $value")
}

Свойство indices

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


val numbers = intArrayOf(1, 2, 3, 4, 5)
for (index in numbers.indices) {
    println("Значение индекса $index равно ${numbers[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 + 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) {
    println("Значение элемента равно $i")
}

Можно одной строкой через 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.contentToString()}")

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


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 ${numbers.contentToString()}:Sorted array ${sortedNumbers
        .contentToString()}")
// 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 

Но можно не писать свой код, а вызвать готовые функции 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 = "${cats[rand]}}"
println(name)

// Kotlin-style
val rand = Random.nextInt(arraySize)
val name = "${cats[rand]}"
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 {str += it * 2}
println(str)

"Оператор +"

Это простой, но коварный способ:

$c = $a + $b

Так добавляются только те ключи, которых еще нет в массиве $a. При этом элементы дописываются в конец массива.

То есть если ключ из массива $b отсутствует в массиве $a, то в результирующем массиве добавится элемент с этим ключом.
Если в массиве $a уже есть элемент с таким ключом, то его значение останется без изменений.

Иными словами от перемены мест слагаемых сумма меняется: $a + $b != $b + $a — это стоит запомнить.

А теперь более подробный пример, чтобы проиллюстрировать это:

$arr1 = ['a' => 1, 'b' => 2];
$arr2 = ['b' => 3, 'c' => 4];

var_export($arr1 + $arr2);
//array (
//    'a' => 1,
//    'b' => 2,
//    'c' => 4,
//)

var_export($arr2 + $arr1);
//array (
//    'b' => 3,
//    'c' => 4,
//    'a' => 1,
//)

Функция array_merge()

Использовать эту функцию можно следующим образом:

$result = array_merge($arr1, $arr2)

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

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

Подробная справка по array_megre.

Функция array_merge_recursive

Делает то же самое, что и array_merge только еще и рекурсивно проходит по каждой ветке массива и проделывает то же самое с потомками. Подробная справка по array_merge_recursive

Функция array_replace()

Заменяет элементы массива элементами других переданных массивов. Подробная справка по array_replace.

Функция array_replace_recursive()

То же что и array_replace только обрабатывает все ветки массива. Справка по array_replace_recursive.

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

Двумерный массив - массив, который в качестве значений хранит в себе другие массивы. Рассмотрим создание двумерного массива с помощью конструктора array():

$flowers = array( array("розы", 100 , 15),
                  array("тюльпаны", 60 , 25),
                  array("орхидеи", 180 , 7) 
                ); 

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

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

Ручной доступ к элементам";

echo $flowers[0][0]." цена ".$flowers[0][1]." количество ".$flowers[0][2]."
"; echo $flowers[1][0]." цена ".$flowers[1][1]." количество ".$flowers[1][2]."
"; echo $flowers[2][0]." цена ".$flowers[2][1]." количество ".$flowers[2][2]."
"; echo "

Использование циклов для вывода элементов

"; echo "
    "; for ($row = 0; $row Номер строки $row"; echo "
    "; for ($col = 0; $col ".$flowers[$row][$col].""; } echo "
"; echo ""; } echo ""; ?>

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

$flowers = array( array( "Название" => "розы", 
                         "Цена" => 100,
                         "Количество" => 15 
                       ),
                  array( "Название" => "тюльпаны", 
                         "Цена" => 60,
                         "Количество" => 25,
                       ),
                  array( "Название" => "орхидеи", 
                         "Цена" => 180,
                         "Количество" => 7 
                       )
                );

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

Мы можем перебрать с помощью цикла for только дочерние массивы. Так как они, в свою очередь, являются ассоциативными, то для перебора их элементов нужно воспользоваться циклом foreach, или перебрать элементы вручную:

 "розы", 
                         "Цена" => 100,
                         "Количество" => 15 
                       ),
                  array( "Название" => "тюльпаны", 
                         "Цена" => 60,
                         "Количество" => 25,
                       ),
                  array( "Название" => "орхидеи", 
                         "Цена" => 180,
                         "Количество" => 7 
                       )
                );

echo "

Ручной доступ к элементам ассоциативного массива

"; for ($row = 0; $row "; } echo "

Использование цикла foreach для доступа к элементам

"; echo "
    "; for ($row = 0; $row Номер строки $row"; echo "
    "; foreach($flowers[$row] as $key => $value) { echo "
  • ".$value."
  • "; } echo "
"; echo ""; } echo ""; ?>

Необязательно использовать для создания двумерного массива конструктор array(), можно воспользоваться и коротким синтаксисом - квадратными скобками:

$flowers = [ [ "Название" => "розы", 
               "Цена" => 100,
               "Количество" => 15 
             ],
             [ "Название" => "тюльпаны", 
               "Цена" => 60,
               "Количество" => 25,
             ],
             [ "Название" => "орхидеи", 
               "Цена" => 180,
               "Количество" => 7 
             ]
           ];