Arrays

Урок J-10. Массивы в Java

24 марта 2014 Мария (admin)

Массив (англ. Array) это объект, хранящий в себе фиксированное количество значений одного типа. Другими словами, массив — это нумерованный набор переменных. Переменная в массиве называется элементом массива, а ее позиция в массиве задается индексом. Например, нам нужно хранить  50 различных имен, согласитесь, неудобно для каждого имени создавать отдельную переменную, поэтому мы будем использовать массив. Нумерация элементов массива начинается с 0, а длинна массива устанавливается в момент его создания и фиксируется.

Для наглядности картинка, взятая мною с The Java Tutorial.

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

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

При создании массива в Java первым делом его нужно объявить. Это можно сделать следующим образом:

Можно также объявить массив так:

Однако, это не приветствуется соглашением по оформлению кода в Java, поскольку скобки обозначают то, что мы имеем дело с массивом и логичнее, когда они находятся рядом с обозначением типа.

Исходя из данного примера, мы объявили 2 массива с именами myFirstArray и   mySecondArray.  Оба массива будут содержать элементы типа int.

Подобным образом можно объявить массив любого типа:

Тип массива задается следующим образом type[], где type это тип данных содержащихся в нем элементов. Скобки являются специальным обозначением того, что переменные содержатся в массиве. Имя массива может быль любым, однако, оно должно соответствовать .

Массивы можно создавать не только из переменных базовых типов, но и из произвольных объектов.

При объявлении массива в языке Java не указывается его размер и не резервируется память для него. Происходит лишь создание ссылки на массив.

Резервация памяти для массива и его инициализация.

Далее, для объявленного myFirstArray, зарезервируем память при помощи ключевого слова new.

В нашем примере мы создали массив из 15 элементов типа int и присвоили его ранее объявленной переменной myFirstArray.

Объявлять имя массива и резервировать для него память также можно на одной строке.

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

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

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

Рассмотрим создание и инициализацию массива на следующем примере. В нем мы создаем массив, содержащий цифры 0-9 и выводим значения на консоль.

Упрощенная форма записи

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

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

Определение размера массива

Размер массива не всегда очевиден, поэтому для того, чтобы его узнать следует использовать свойство length, которое возвращает длину массива.

Данный код поможет нам узнать, что длина массива myColor равна 3.

Пример: Задано 4 числа, необходимо найти минимальное

Упражнения на тему одномерные массивы в Java:

  1. Создайте массив, содержащий 10 первых нечетных чисел. Выведете элементы массива на консоль в одну строку, разделяя запятой.
  2. Дан массив размерности N,  найти наименьший элемент массива и вывести на консоль (если наименьших элементов несколько — вывести их все).
  3. В массиве из задания 2. найти наибольший элемент.
  4. Поменять наибольший и наименьший элементы массива местами. Пример: дан массив {4, -5, 0, 6, 8}.  После замены будет выглядеть {4, 8, 0, 6, -5}.
  5. Найти среднее арифметическое всех элементов массива.

Категория: Уроки Java

Перейдём к практике

Приступим к созданию массива объектов. Представьте, что у нас есть класс ObjMass и всё, что в нём есть, — это массив объектов Dog из трёх элементов:

    public class ObjMass {
    Dog[] name = new Dog 3];
}

Прекрасно. Но так как класс Dog мы раньше не описывали (интерпретатор Java знать не знает, что такое Dog и откуда его взять), то название объекта выделится красным. Исправим это, создав параллельно класс Dog:

    class ObjMass {
    Dog[] abc = new Dog 3];
}

class Dog{

}

Так, хорошо. Но зачем нам массив, состоящий из пустых объектов? Пусть у собак будут хотя бы клички:

    class ObjMass {
    Dog[] abc = new Dog 3];
}

class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

Вот, теперь Dog имеет содержание.

Давайте сейчас обратимся к объектам, которые ещё не созданы, как говорится, расширим пример

Обратите ваше внимание, что у нас перед массивом объектов Dog находится модификатор static. Также добавим метод main:

    class ObjMass {
    static Dog[] abc = new Dog 3];

    public static void main (String[] args){
        }
    }
}

class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

Для вывода массива на экран создаём цикл. И выводим не имена собак (abc.name), а объекты — abc:

    class ObjMass {
   static Dog[] abc = new Dog 3];

    public static void main (String[] args){
        for (int i = ; i<3; i++){
            System.out.println(abci]);
        }
    }
}
class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

И увидим следующий результат:

null
null
null

Это и есть значения по умолчанию, при ссылке на которые возникнет ошибка NullPointerException. Она появляется, когда мы ссылаемся на свойство null-ного объекта. К примеру, давайте попробуем вывести на экран имена собак (abc.name):

    class ObjMass {
   static Dog[] abc = new Dog 3];

    public static void main (String[] args){
        for (int i = ; i<3; i++){
            System.out.println(abciname);
        }
    }
}

class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

Результатом станет тот самый NullPointerException. Чтобы этого не допустить, массив объектов надо заполнить:

    class ObjMass {
   static Dog[] abc = new Dog 3];

    public static void main (String[] args){
        abc = new Dog("Billy");
        abc1 = new Dog("Tom");
        abc2 = new Dog("Jonny");

        for (int i = ; i<3; i++){
            System.out.println(abciname);
        }
    }
}

class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

Результат выполнения кода:

Billy 
Tom 
Jonny 

Вот и всё, теперь вы знакомы с особенностями применения массива объектов в Java и знаете, как добавить объект в массив. В прочих аспектах всё функционирует практически так же, как и в массивах примитивных типов.

Вставка элементов

Как вставить новое значение в массив в Java:

int[] ints   = new int;

int insertIndex = 10;
int newValue    = 123;

//move elements below insertion point.
for(int i=ints.length-1; i > insertIndex; i--){
    ints = ints;
}

//insert new value
ints = newValue;

System.out.println(Arrays.toString(ints));

В примере:

  1. Создается массив.
  2. Он определяет индекс вставки и новое значение для вставки.
  3. Все элементы от индекса вставки и до конца массива сдвигаются на один индекс вниз в массиве.

Приведенный выше код вставки массива может быть встроен в метод:

public void insertIntoArray(
        int[] array, int insertIndex, int newValue){

    //move elements below insertion point.
    for(int i=array.length-1; i > insertIndex; i--){
        array = array;
    }

    //insert new value
    array = newValue;
}

Этот метод принимает массив int[] в качестве параметра, а также индекс для вставки нового значения и нового значения. Вставка элементов в массив, вызвав этот метод следующим образом:

int[] ints   = new int;

insertIntoArray(ints, 0, 10);
insertIntoArray(ints, 1, 23);
insertIntoArray(ints, 9, 67);

Конечно, если метод insertIntoArray() находится в другом классе, нежели приведенный выше код, потребуется объект этого класса, чтобы вызывать метод. Если метод insertIntoArray() был статическим, нужно поместить имя класса и точку перед именем метода.

Операции с ArrayList

Изначально длина только что созданного списка равна нулю: он содержит 0 элементов. Если в список добавить один элемент, его длина увеличится на 1. Если удалить добавленный элемент, опять уменьшится до нуля.

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

Методы Описание
Добавляет в список переданный элемент
Добавляет элемент в определенное место списка.
Возвращает элемент, который находится под номером
Меняет значение элемента с номером на
Удаляет элемент под номером . Возвращает удаленный элемент.
Удаляет элемент: нужно передать сам элемент в список. Если таких элементов несколько, будет удален первый из них.
Очищает список — удаляет все элементы из списка.
Проверяет, содержится ли в списке элемент .
Проверяет, пустой список или нет. Равна ли длина списка нулю.
Возвращает размер списка — количество элементов списка.
Возвращает массив, содержащий те же элементы, что и список.Массив нужно передать в метод.

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

Как создать массив в Java

При объявлении массива создается только ссылка на массив. Чтобы фактически создать или предоставить память массиву, надо создать массив следующим образом: общая форма new применительно к одномерным и выглядит следующим образом:

Здесь type указывает тип данных, size — количество элементов в массиве, а var-name-имя переменной массива.

Пример:

int intArray[];    //объявление
intArray = new int;  // выделение памяти 

или

int[] intArray = new int; // объединение

Основы Java. МассивыОсновы Java. Массивы

Литералы массива

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

int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 }; 
 // Declaring array literal
  • Длина этого массива определяет длину созданного массива.
  • Нет необходимости писать int[] в последних версиях Java

Доступ к элементам массива Java с помощью цикла for

Доступ к каждому элементу массива осуществляется через его индекс. Индекс начинается с 0 и заканчивается на (общий размер)-1. Все элементы могут быть доступны с помощью цикла for.

// accessing the elements of the specified array
for (int i = 0; i < arr.length; i++)
  System.out.println("Element at index " + i + 
                                " : "+ arr);

// Пример для иллюстрации создания array // целых чисел, помещает некоторые значения в массив, // и выводит каждое значение.

class GFG { public static void main (String[] args) { // declares an Array of integers. int[] arr;

// allocating memory for 5 integers. arr = new int;

// initialize the first elements of the array arr = 10;

// initialize the second elements of the array arr = 20;

//so on… arr = 30; arr = 40; arr = 50;

// accessing the elements of the specified array for (int i = 0; i < arr.length; i++) System.out.println(«Element at index » + i + » : «+ arr); } } В итоге получаем:

Element at index 0 : 10
Element at index 1 : 20
Element at index 2 : 30
Element at index 3 : 40
Element at index 4 : 50

Быстрая инициализация массива в Java

Массивы — очень полезная вещь, поэтому разработчики Java постарались сделать работу с ними максимально удобной.

И первое, что они сделали — это упростили инициализацию массива, занесение в него стартовых значений.

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

Но есть способ записать его короче — спасибо создателям Java:

Можно просто перечислить через запятую все значения массива!

Удобно, да? Но и это еще не все.

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

Поэтому этот код можно записать еще короче:

Разве не красота?

Такая запись называется «быстрая инициализация массива». Она, кстати, работает не только для типа …

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

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

int[] intArray;
float[] floatArray; 
char[] charArray;

Приведённые выше операторы объявления сообщают компилятору, что intArrayvariable – это массив целых чисел, floatArrayis – массив чисел с плавающей запятой, а charArrayis – массив символов.

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

intArray = new int;

Число внутри скобок указывает, сколько элементов содержится в массиве. Приведённый выше код создает массив целых чисел, состоящий из 10 элементов.

Объявление и установку размера массива можно сделать в одном выражении:

float[] floatArray = new float;

Массивы не ограничиваются примитивными типами данных. Также можно создавать Java массив строк или объектов:

String[] names = new String;

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

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

Важно отметить, что индекс первого элемента –. Обычно путаница возникает тогда, когда начинаешь думать, что раз в массиве 10 элементов, то их индексы будут перечисляться с 1 до 10

Но на самом деле счет идет от до 9. Например, возвращаясь к примеру с лотерей, можно создать массив из 6 элементов, и задать им числа из лотереи:

int[] lotteryNumbers = new int;
lotteryNumbers = 16;
lotteryNumbers = 32;
lotteryNumbers = 12;
lotteryNumbers = 23;
lotteryNumbers = 33;
lotteryNumbers = 20;

Сокращённый способ заполнения массива:

int[] lotteryNumbers = {16,32,12,23,33,20};

String[] names = {"John", "James", "Julian", "Jack", "Jonathon"};

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

Чтобы получить значение элемента, используется его индекс:

System.out.println("The value of the first element is " + lotteryNumbers);

Чтобы узнать в Java длину массива, используется поле length:

System.out.println("The lotteryNumbers array has " + lotteryNumbers.length + " elements");

Примечание: распространена ошибка при использовании метода length, когда значение length используется как индексная позиция. Это всегда выдаст ошибку, так как индексные позиции массива , в то время как позиция length – 1.

Многомерные массивы

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

int[][] lotteryNumbers = {{16,32,12,23,33,20},{34,40,3,11,33,24}};

Индекс многомерных массивов содержит два числа:

System.out.println("The value of element 1,4 is " + lotteryNumbers);

При этом длина массивов, находящихся внутри многомерного массива Java, не обаятельно должна быть одинаковой:

String[][] names = new String;

Копируем массив

Чтобы скопировать массив, проще всего использовать arraycopymethod из класса System. Метод принимает пять параметров: исходный массив, позиция в индексе (с которой необходимо начать копирование элементов), новый массив, позиция в индексе для начала вставки и количество копируемых элементов:

public static void arraycopy (Object src, int srcPos, Object dest, int destPos, int length)

В примере мы создаём новый массив, в котором содержатся последние четыре элемента из массива int:

int[] lotteryNumbers = {16,32,12,23,33,20};
int[] newArrayNumbers = new int;
System.arraycopy(lotteryNumbers, 2, newArrayNumbers, 0, 4);

Так как массивы имеют фиксированную длину, arraycopymethod позволяет удобно изменять длину массива.

Чтобы лучше познакомиться с массивами, можете прочитать о том, как управлять массивами при помощи класса Arrays. А также о создании в Java динамических массивов (то есть, массивов с нефиксированным количеством элементов) при помощи класса ArrayList.

Данная публикация является переводом статьи «Working With Arrays in Java» , подготовленная редакцией проекта.

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

Чтобы быть равными, массивы должны иметь одинаковый тип и число элементов, а каждый элемент должен быть равен каждому соответствующему элементу другого массива.

Класс Object  имеет метод equals, который наследуется массивами и не является перегруженным и сравнение идет по адресам объектов, а не по содержимому. Метод  equals перегружен только в классе Arrays. Отсюда вытекает правило сравнения массивов:

  • a == b сравниваются адреса массивов
  • a.equals(b) сравниваются адреса массивов
  • Arrays.equals(a, b) сравнивается содержимое массивов
  • Arrays.deepEquals(a, b) сравнивается содержимое многомерных массивов

Формат метода

Boolean f=Arrays.equals([]a,[]b);

Метод вернет true, если содержимое массивов равно, в противном случае false.

Пример.

int ar1[] = {0,2,3,4,5,1};
int ar2[] = {0,2,3,4,5,1};
//это сравнение ссылок      
System.out.println(ar1.equals(ar2));  //вернет fasle
//это сравнение содержимового
System.out.println(Arrays.equals(ar1,ar2)); // вернет true
System.out.println("");
    ar1=6;
System.out.println(Arrays.equals(ar1,ar2)); // вернет false
System.out.println("");

Передача массивов в метод

Как и переменные, мы можем передавать массивы в методы.

// Java program to demonstrate
// passing of array to method

class Test
{
// Driver method
public static void main(String args[])
{
int arr[] = {3, 1, 2, 5, 4};

// passing array to method m1
sum(arr);

}

public static void sum(int[] arr)
{
// getting sum of array values
int sum = 0;

for (int i = 0; i < arr.length; i++)
sum+=arr;

System.out.println("sum of array values : " + sum);
}
}

На выходе получим:

sum of array values : 15

Возврат массивов из методов

Как обычно, метод также может возвращать массив. Например, ниже программа возвращает массив из метода m1.

// Java program to demonstrate
// return of array from method

class Test
{
// Driver method
public static void main(String args[])
{
int arr[] = m1();

for (int i = 0; i < arr.length; i++)
System.out.print(arr+" ");

}

public static int[] m1()
{
// returning array
return new int[]{1,2,3};
}
}

Creating Arrays

You can create an array by using the new operator with the following syntax −

Syntax

arrayRefVar = new dataType;

The above statement does two things −

  • It creates an array using new dataType.

  • It assigns the reference of the newly created array to the variable arrayRefVar.

Declaring an array variable, creating an array, and assigning the reference of the array to the variable can be combined in one statement, as shown below −

dataType[] arrayRefVar = new dataType;

Alternatively you can create arrays as follows −

dataType[] arrayRefVar = {value0, value1, ..., valuek};

The array elements are accessed through the index. Array indices are 0-based; that is, they start from 0 to arrayRefVar.length-1.

Example

Following statement declares an array variable, myList, creates an array of 10 elements of double type and assigns its reference to myList −

double[] myList = new double;

Following picture represents array myList. Here, myList holds ten double values and the indices are from 0 to 9.

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

Существует несколько стандартных алгоритмов
обработки элементов массива:

  1. Удаление значения из массива по
    определенному индексу.

  2. Вставка значения в массив по
    определенному индексу.

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

Начнем с первого
– удаления элемента из массива. Создадим вот такой массив:

final int N = 9;
short a = new shortN;

запишем туда
значения с 1 по 9:

for(int i=;i < N;++i) ai = (short)(i+1);

Теперь удалим
элемент со значением 6. Для этого нужно проделать такую операцию:

Причем, сначала
перемещаем 7-ку на место 6-ку, затем 8-ку и 9-ку, то есть, двигаемся от
удаляемого элемента к концу массива. Программа будет выглядеть так:

final int N = 9;
short a = new shortN;
 
for(int i=;i < N;++i) ai = (short)(i+1);
 
for (int i = 5; i < N-1; ++i)
    ai = ai + 1;
 
for (short val  a) System.out.print(val+" ");

Здесь мы начали
движение с 5-го индекса (то есть 6-го элемента массива) и на первой итерации
делаем операцию a=a, то есть, 7-ку ставим на место 6-ки.
На следующей итерации уже имеем a=a – перемещаем
8-ку и, затем, a=a – перемещаем 9-ку. Все, в итоге
значение 6 было удалено из массива.

Теперь реализуем второй алгоритм и
вставим значение 4, которого не хватает вот в таком массиве:

short a = new short {1, 2, 3, 5, 6, 7, 8, 9, 9};

Здесь в конце записаны две 9, чтобы мы
могли сдвинуть все элементы на 1 вправо и вставить элемент со значением 4. То
есть, нам следует выполнить такую операцию над элементами массива:

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

Итак, вот программа,
которая вставляет 4-ку в этот массив:

short a = new short {1, 2, 3, 5, 6, 7, 8, 9, 9};
 
for (int i = 8; i > 3; --i)
 
    ai = ai - 1;
 
a3 = 4;
 
for (short val  a) System.out.print(val+" ");

Здесь счетчик i в цикле сначала
равен 8 – это индекс последнего элемента нашего массива. Затем, делается
операция a=a, то есть, a=a. Таким
образом, мы присваиваем 8-му элементу значение 7-го элемента. Это и есть
смещение значения вправо. На следующей итерации i уменьшается на
1, то есть, равно 7 и операция повторяется: a=a и так далее,
последний смещаемый элемент будет: a=a. После этого
i будет равно 3,
условие цикла становится ложным и он завершается. После смещения, мы
присваиваем 4-му элементу массива значение 4 и выводим получившийся массив на
экран.

Теперь
рассмотрим довольно распространенный алгоритм сортировки элементов массива по
методу всплывающего пузырька. Реализуем его на языке Java.

byte a = {3, 5, 1, 6, 2, 4};
 
for (int i = ; i < a.length-1; ++i) {
    byte min = ai;
    int pos = i;
 
    for (int j = i + 1; j < a.length; ++j)
        if (min > aj) {
            pos = j;
            min = aj;
        }
 
    byte t = ai;
    ai = apos;
    apos = t;
}
 
for (short val  a) System.out.print(val+" ");

Здесь первый
цикл показывает с какого элемента искать минимальный, то есть, это
местоположение той вертикальной черты в методе всплывающего пузырька. Затем,
задаем две вспомогательные переменные min – минимальное найденное
значение, pos – индекс
минимального элемента в массиве. Второй вложенный цикл перебирает все
последующие элементы массива и сравнивает его с текущим минимальным и если
будет найдено меньшее значение, то min становится
равной ему и запоминается его позиция. Вот эти три строчки меняют местами
текущее значение элемента с найденным минимальным, используя вспомогательную
переменную t. И в конце
программы выполняется вывод элементов массива на экран.

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

Видео по теме

#1 Установка пакетов и первый запуск программы

#2 Структура программы, переменные, константы, оператор присваивания

#3 Консольный ввод/вывод, импорт пакетов

#4 Арифметические операции

#5 Условные операторы if и switch

#6 Операторы циклов while, for, do while

#7 Массивы, обработка элементов массива

#8 (часть 1) Строки в Java, методы класса String

#8 (часть 2) Строки — классы StringBuffer и StringBuider

#9 Битовые операции И, ИЛИ, НЕ, XOR

#10 Методы, их перегрузка и рекурсия

Инициализируем двухмерный массив в Java

Давайте посмотрим, как инициализируется многомерный (в нашем случае — двумерный) Java-массив:

int[][] a = {
      {1, 2, 3}, 
      {4, 5, 6, 9}, 
      {7}, 
};

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

Докажем это с помощью кода:

class Two2DArray {
   public static void main(String[] args) {

      int[][] a = {
            {1, 2, 3}, 
            {4, 5, 6, 9}, 
            {7}, 
      };

      System.out.println("Длина ряда № 1: " + alength);
      System.out.println("Длина ряда № 2: " + a1length);
      System.out.println("Длина ряда № 3: " + a2length);
   }
}

Результат будет следующим

Длина ряда 1: 3
Длина ряда 2: 4
Длина ряда 3: 1

Т. к. многомерный массив включает в себя отдельные массивы (a, a и a), мы можем задействовать метод length, чтобы определить длину каждого ряда 2-мерного Java-массива.

Теперь выведем на экран все элементы двумерного массива, используя циклы:

class TwoDArray {
   public static void main(String[] args) {

      int[][] a = {
            {1, -2, 3}, 
            {-4, -5, 6, 9}, 
            {7}, 
      };

     for (int i = ; i < a.length; ++i) {
        for(int j = ; j < ailength; ++j) {
           System.out.println(ai]);
        }
     }
   }
}

Когда надо пройтись по элементам массива, использование цикла for…each — одно из лучших решений. Пример сортировки двухмерного Java-массива мы можем записать посредством цикла for…each таким образом:

class TwoDArray {
   public static void main(String[] args) {

      int[][] a = {
            {1, -2, 3}, 
            {-4, -5, 6, 9}, 
            {7}, 
      };

     for (int[] innerArray a) {
        for(int data innerArray) {
           System.out.println(data);
        }
     }
   }
}

Запустив этот код, мы увидим итог заполнения двумерного Java-массива:

1
-2
3
-4
-5
6
9
7

Оцените статью
Рейтинг автора
5
Материал подготовил
Илья Коршунов
Наш эксперт
Написано статей
134
Добавить комментарий