Java-массив: что это такое и с чем его едят?

How to Initialize Arrays in Java?

In Java, we can initialize arrays during declaration. For example,

Here, we have created an array named age and initialized it with the values inside the curly brackets.

Note that we have not provided the size of the array. In this case, the Java compiler automatically specifies the size by counting the number of elements in the array (i.e. 5).

In the Java array, each memory location is associated with a number. The number is known as an array index. We can also initialize arrays in Java, using the index number. For example,

Java Arrays initialization

Note:

• Array indices always start from 0. That is, the first element of an array is at index 0.
• If the size of an array is n, then the last element of the array will be at index n-1.

Перебор Элементов

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

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

void initializeElements(int[][] multiDimensionalArr) {
    Scanner sc = new Scanner(System.in);
    for (int outer = 0; outer < multiDimensionalArr.length; outer++) {
        for (int inner = 0; inner < multiDimensionalArr.length; inner++) {
            multiDimensionalArr = sc.nextInt();
        }
    }
}

Здесь Многомерный Arr.длина – это длина массива с индексом внешний в многомерном Arr .

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

Инициализация

Теперь есть два способа инициализировать двумерный массив в Java:

1. используя литерал массива во время создания.
2. используя вложенный цикл for.

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

// initializing two dimensional array as literal 
String[][] names = { 
 {"Sam", "Smith"},
 {"Robert", "Delgro"},
 {"James", "Gosling"},
};
 int[][] board = new int;
 for (int i = 0; i < board.length; i++) {
 for (int j = 0; j < board.length; j++) {
 board = i + j;
 }
                   }

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

Как вывести

Если вы хотите получить доступ к каждому элементу, то вам нужно выполнить итерацию по двумерному массиву, используя два цикла for. Почему? Потому что вам нужно два индекса для доступа к отдельному элементу.

Вы можете использовать расширенный для каждого цикла или классический для цикла со счетчиком. Для того, чтобы напечатать(сделать вывод) содержимое 2D массива, вы можете использовать либо этот метод, либо Arrays.deepToString(), который возвращает строку всех элементов.

import java.util.Arrays;

/**
* Java Program to initialize and print two dimensional array in Java.
*/
class Basics {

public static void main(String args[]) {

// initializing two dimensional array as literal
String[][] names = {
{"John", "Smith"},
{"Javin", "Paul"},
{"James", "Gosling"},
};

// how to initialize two dimensional array in Java
// using for loop
int[][] board = new int;

for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board.length; j++) {
board = i + j;
}
}

// now let's print a two dimensional array in Java
for (int[] a : board) {
for (int i : a) {
System.out.print(i + "\t");
}
System.out.println("\n");
}

// printing 2D array using Arrays.deepToString() method
System.out.println("another way to print 2D arrays");
System.out.println(Arrays.deepToString(board));

}

}
Output:
0 1 2

1 2 3

2 3 4

another way to print 2D arrays
, , ]

Java Array Introduction

For example, an integer array in Java will store all the integer elements. If you try to insert a float or char value, then it will throw an error.

The length of a Java array decided when we are creating an array. Once it created, the length is fixed. We have 3 types of arrays in Java Programming

1. One Dimensional Array
2. Two Dimensional Array
3. Multi-Dimensional Array
   • Three Dimensional Array
   • Four Dimensional Array etc

Java array declaration or Syntax

The following code snippet will show you the most basic way of Java array declaration:

• Data_type: It will decide the type of elements array will accept. For example, If we want to store integer values, the Data Type will be declared as an int, to store Float values the Data Type is float
• Array_Name: This is the name you want to give it to an array. For example, students, age, marks, emp

Similarly, you can declare the remaining type of arrays in Java as follows:

Create a Java Array

In order to create an array in Java, we have to use the New operator

Array_Size: Number of elements an array can hold or store. For example, Array_Size =10, then the array will hold 10 values.

If you already initialized an array in java then

For Example, int[] Student_Marks = new int;

1. We used int as the data type to declare an array. So, the above array will accept only integers. If we try to add float values, then it will throw an error.
2. Student_Age is the array name
3. The size of an Array is ten. It means Student_Marks array will only accept ten integer values.
   • If we try to store more than ten, then it throws an error.
   • We can store less than 10. For Example, If we store three integer values, then the remaining two values will be initialized to the default value (Which is 0).

Java Array Initialization

There are multiple ways to initialize the array in Java Programming language

First Approach

Declaring and Creating an Array in Java Programming 

int[] Student_Marks = new int;

Initializing Array elements in more traditional way

Second Approach to create an Array in Java

In this approach, We initialize the array at the declaration time only

int[] anIntegerArray = {15, 25, 35, 45, 55}

Here, We did not mention the array size. However, the Javac is intelligent enough to determine the array size by checking the number of elements.

Third Approach

Although this approach works without any error, this is not the preferred way to initialize a java array

int Employees = {1, 2, 3, 4, 5}

Fourth Approach

The above 3 methods are good to store a small number of items into an array. What if we want to store 50, 100, or more values. It will be a torture to add all of them using any of the approaches mentioned above. To resolve this, we can use the loop concept to store data into a java array here:

TIP: In order to store the elements in an array, We can use For loop, While Loop and Do While Loop

Fifth Approach of creating an array in Java

int[] anIntegerArray = new int;anIntegerArray = 10;anIntegerArray = 20;anIntegerArray = 30;

Here we declared an anIntegerArray array of size 5, but we only assigned three values to it. In this condition, the remaining values assigned to default values (0 in this case).

The above array will be:

Accessing Java Array Elements

We use the index position to access the items of an Array in Java. Using an index, we can access or alter/change array item. Index value starts at 0 and ends at n-1, where n is the size or length of an array.

For example, if an array stores ten elements, the index starts at 0 and ends at 9. To access or modify the first value, use Array_Name and to access or alter 10th value, use Array_Name. Let us see the example for better knowledge of accessing Java array elements:

Other Array Techniques

You can actually create Java arrays of unknown lengths immediately, unlike C++ arrays and arrays from a lot of other programming languages.

Above I’m getting user input to tell me how big to make the array.

You can also preset the values of the variables inside the array. Here’s an example of creating a char array, but creating it with the values already inside.

This creates a character array of length 4, because there are 4 elements inside the comma separated list given inside curly brackets. You can put as many or as few elements as you like inside the curly brackets, just make sure those elements are separated by commas. The array is automatically the size of the number of elements you provide.

In case you forgot, the reason those letters have single quotes around them is because char values always have the single quotes around them.

Note: Once the size of an array variable is given, it cannot easily be changed, so if you need an array to hold a large number of values, try to figure out the absolute maximum size the array might have to be.

In the next tutorial we’re gonna have another look at Java methods. As always, I’ll take any questions or comments in the form below. Until next time…

If you have any questions, comments, or concerns, feel free to contact us.

Инициализируем массив, работаем с его элементами

Теперь мы знаем, что такое массив, но как его использовать — пока непонятно. Как загружать в него информацию, а потом ее оттуда извлекать? Давайте разбираться.

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

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

Из-за операционной системы, виртуальной памяти и других факторов для извлечения элемента из массива может потребоваться несколько больше, чем один фактический компьютерный цикл. Но время извлечения первого элемента такое же, как и 100-го элемента и 500-тысячного. Никакая другая созданная нами структура данных не может быть быстрее, чем массив. Все «продвинутые» системы реализованы с их использованием.

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

Например, создадим массив, содержащий в себе четыре стороны света, и заполним его значениями:

String[] sides  = new String; /* объявленному массиву Java выделил память для четырех строк (по умолчанию их значение будет null, потому что String относится к ссылочному типу)*/
sides = "North"; /* Получив доступ к первой ячейке (с нулевым индексом), мы вписали туда  строковое значение  */
sides = "South"; // тоже самое мы проделываем с ячейкой под индексом 1
sides = "West"; // 2
sides = "East"; // 3

Мы используем индексы для доступа к ячейкам массива, число в скобках обозначает каждую конкретную позицию. Если переданный при доступе к ячейке индекс — отрицательный или превышает длину массива, Java выдаст исключение .

Теперь совместим инициализацию с объявлением:

String[] sides = new String[] {"North", "South", "West", "East"};

И уберем оператор , тем самым упростив запись:

String[] sides = {"North", "South", "West", "East"};

The Arrays Class

The java.util.Arrays class contains various static methods for sorting and searching arrays, comparing arrays, and filling array elements. These methods are overloaded for all primitive types.

Sr.No.	Method & Description
1	public static int binarySearch(Object[] a, Object key) Searches the specified array of Object ( Byte, Int , double, etc.) for the specified value using the binary search algorithm. The array must be sorted prior to making this call. This returns index of the search key, if it is contained in the list; otherwise, it returns ( – (insertion point + 1)).
2	public static boolean equals(long[] a, long[] a2) Returns true if the two specified arrays of longs are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. This returns true if the two arrays are equal. Same method could be used by all other primitive data types (Byte, short, Int, etc.)
3	public static void fill(int[] a, int val) Assigns the specified int value to each element of the specified array of ints. The same method could be used by all other primitive data types (Byte, short, Int, etc.)
4	public static void sort(Object[] a) Sorts the specified array of objects into an ascending order, according to the natural ordering of its elements. The same method could be used by all other primitive data types ( Byte, short, Int, etc.)

Previous Page
Print Page

Next Page  

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

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

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

Структура многомерного массива в Java (здесь мы видим свободные места в кинотеатре)

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

— означает, что место доступно, 1 — что занято. Мы также могли бы добавить еще и 2 для зарезервированных мест и так далее. Но пока ограничимся более простым примером.

Java не предоставляет никакой специальной поддержки для многомерных массивов, но мы можем легко объявить их как массив массивов. Это будет выглядеть вот так:

int [] [] cinema = новый int  ;

Первое число указывает количество столбцов, второе — количество строк. Все числовые массивы в Java автоматически инициализируются нулевыми значениями после объявления. Мы только что создали таблицу, полную нулей.

Теперь давайте заполним кинозал единицами, как на картинке выше. Для создания строки из единиц используем несколько циклов . Чтобы открыть доступ к элементам 2D-массива, мы должны ввести координаты столбцов и строк:

cinema = 1; // центр
for (int i = 1; i < 4; i++) { // четвертая строка
    cinema = 1;
}
for (int i = 0; i < 5; i++) { // последняя строка
    cinema = 1;
}

Нужно иметь в виду, что если мы запросим , он будет содержать количество столбцов (длину внешнего массива, представляющего столбцы). Чтобы определить количество строк (длину внутреннего массива), необходимо запросить cinema

Обратите внимание, что для работы должен быть хотя бы один столбец

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

for (int j = 0; j < cinema.length; j++) {
    for (int i = 0; i < cinema.length; i++) {
        System.out.print(cinema);
}
    System.out.println();
}

Результат:

00000
00000
00100
01110
11111  

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

3D-массив

Давайте создадим 3D-массив:

int [] [] [] cinemas = новый int   ; 

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

cinemas = 1; // кинотеатр на втором этаже, третий ряд, четвертое место 

В такой ситуации, если мы запросим , то получим количество этажей.

Параллельные операции над массивами

Последнее обновление: 30.04.2018

В JDK 8 к классу Arrays было добавлено ряд методов, которые позволяют в параллельном режиме совершать обработку элементов массива.
И хотя данные методы формально не входят в Stream API, но реализуют схожую функциональность, что и параллельные потоки:

• parallelPrefix(): вычисляет некоторое значение для элементов массива (например, сумму элементов)

• parallelSetAll(): устанавливает элементы массива с помощью лямбда-выражения

• parallelSort(): сортирует массив

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

import java.util.Arrays;
public class Program {

    public static void main(String[] args) {
		
        int[] numbers = initializeArray(6);
        for(int i: numbers)
            System.out.println(i);
        
    } 
    public static int[] initializeArray(int size) {
        int[] values = new int;
        Arrays.parallelSetAll(values, i -> i*10);
        return values;
    }
}

В метод передается два параметра: изменяемый массив и функция, которая устанавливает элементы массива. Эта
функция перебирает все элементы и в качестве параметра получает индекс текущего перебираемого элемента. Выражение означает,
что по каждому индексу в массиве будет хранится число, равное i * 10. В итоге мы получим следующий вывод:

0
10
20
30
40
50

Рассмотрим более сложный пример. Пусть у нас есть следующий класс Phone:

class Phone{
    
    private String name;
    private int price;
    
    public Phone(String name, int price){
        this.name=name;
        this.price = price;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String val) {
        this.name=val;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int val) {
        this.price=val;
    }
}

Теперь произведем манипуляции с массивом объектов Phone:

Phone[] phones = new Phone[]{new Phone("iPhone 8", 54000), 
    new Phone("Pixel 2", 45000),
    new Phone("Samsung Galaxy S9", 40000),
    new Phone("Nokia 9", 32000)};
        
Arrays.parallelSetAll(phones, i -> {
    phones.setPrice(phones.getPrice()-10000); 
    return phones;
});
        
for(Phone p: phones)
    System.out.printf("%s - %d \n", p.getName(), p.getPrice());

Теперь лямбда-выражение в методе представляет блок кода. И так как лямбда-выражение должно возвращать объект, то нам надо явным образом использовать
оператор return. В этом лямбда-выражении опять же функция получает индексы перебираемых элементов, и по этим индексам мы можем обратиться
к элементам массива и их изменить. Конкретно в данном случае происходит уменьшение цены смартфонов на 10000 единиц. В итоге мы получим следующий
консольный вывод:

iPhone 8 - 44000 
Pixel 2 - 35000 
Samsung Galaxy S9 - 30000 
Nokia 9 - 22000 

Сортировка

Отсортируем массив чисел в параллельном режиме:

int[] nums = {30, -4, 5, 29, 7, -8};
Arrays.parallelSort(nums);
for(int i: nums)
    System.out.println(i);

Метод в качестве параметра принимает массив и сортирует его по возрастанию:

-8
-4
5
7
29
30

Если же нам надо как-то по-другому отсортировать объекты, например, по модулю числа, или у нас более сложные объекты, то мы можем создать свой компаратор и передать его в качестве второго параметра в
. Например, возьмем выше определенный класс Phone и создадим для него компаратор:

import java.util.Arrays;
import java.util.Comparator;
public class Program {
 
    public static void main(String[] args) {
         
        Phone[] phones = new Phone[]{new Phone("iPhone 8", 54000), 
		new Phone("Pixel 2", 45000),
		new Phone("Samsung Galaxy S9", 40000),
		new Phone("Nokia 9", 32000)};
        
        Arrays.parallelSort(phones,new PhoneComparator());
        
         for(Phone p: phones)
            System.out.println(p.getName());
    }
}
class PhoneComparator implements Comparator<Phone>{
 
    public int compare(Phone a, Phone b){
     
        return a.getName().toUpperCase().compareTo(b.getName().toUpperCase());
    }
}

Метод parallelPrefix

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

int[] numbers = {1, 2, 3, 4, 5, 6};
Arrays.parallelPrefix(numbers, (x, y) -> x * y);

for(int i: numbers)
    System.out.println(i);

Мы получим следующий результат:

1
2
6
24
120
720

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

НазадВперед

Итерация

Как перебрать все элементы массива, используя цикл Java for:

String[] stringArray = new String;

for(int i=0; i < stringArray.length; i++) {
    stringArray = "String no " + i;
}

for(int i=0; i < stringArray.length; i++) {
    System.out.println( stringArray );
}

В этом примере:

1. Сначала создается массив ссылок String. Когда  впервые создаете массив ссылок на объекты, каждая из ячеек в массиве указывает на ноль, а не на объект.
2. Первый из двух циклов for выполняет итерацию по массиву String, создает строку и делает ссылку на ячейку этой строкой.
3. Второй из двух циклов for перебирает массив String и печатает все строки, на которые ссылаются ячейки.

Если бы это был массив int (примитивные значения), он мог бы выглядеть так:

int[] intArray = new int;

for(int i=0; i < intArray.length; i++) {
    intArray = i;
}

for(int i=0; i < intArray.length; i++) {
    System.out.println( intArray );
}

Переменная i инициализируется равной 0 и работает до длины массива минус 1. В этом случае i принимает значения от 0 до 9, каждый раз повторяя код внутри цикла for один раз, и для каждой итерации i имеет другое значение.

Как перебрать массив с помощью цикла «for-each» в Java. Вот как это выглядит:

int[] intArray = new int;

for(int theInt : intArray) {
    System.out.println(theInt);
}

Цикл for-each дает вам доступ к каждому элементу в массиве по одному, но не информацию об индексе каждого элемента. Есть доступ только к значению. Изменить значение элемента в этой позиции невозможно. Если это нужно, используйте обычный цикл for, как показано ранее.

Цикл for-each также работает с массивами объектов. Вот пример, как выполнить итерацию массива объектов String:

String[] stringArray = {"one", "two", "three"};

for(String theString : stringArray) {
    System.out.println(theString);
}

Вернуть 3D-массив из метода

Мы также можем вернуть трехмерный массив из метода в Java, который содержит 3 строки и 3 столбца. Пример ниже иллюстрирует то же самое.

public class Return3DArray {

  public static void main(String[] args) {
    createArray c = new createArray();
    int[][] arrData = c.ArrayCreation();
    System.out.println("Array values");

    for(int i=0;i<3;i++) {
      for(int j=0;j<3;j++)
        System.out.print(arrData + " ");
      System.out.println();
    }
  }

}

class createArray {
  public int[][] ArrayCreation(){
    int[][] a = new int;
    for(int i=0;i<3;i++) {
      for(int j=0;j<3;j++) {
        a = i+1;
      }
    }
    return a;
  }
  
}

Array values
1 1 1 
2 2 2 
3 3 3 

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

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

Класс 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("");

Сортировка массивов

 Метод  Arrays.sort([]a)

Метод sort() из класса Arrays использует усовершенствованный алгоритм Быстрой сортировки (Quicksort), который эффективен  для большинства  набора данных.  Метод упорядочивает весь массив в порядке возрастания значений элементов.

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

Arrays.sort([]a),

[]a – исходный массив, после работы метода массив будет содержать упорядоченные значения элементов в порядке возрастания.

Пример.

//исходный массив
double a[] = { 41.5, 11.4, 11.2, 3.1, 4.3, 5.5 };
//сортировка
Arrays.sort(a);
//результат сортировки
for(int i=0; i<a.length; i++)
System.out.print(a+"  ");  //3.1  4.3  5.5  11.2  11.4  41.5 
System.out.println();

 Метод  Arrays.sort([]a,index1,index2)

выполняет сортировку части массива по возрастанию массива от index1 до index2 минус единица

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

Arrays.sort([]a,index1,index2),

 []a – исходный массив

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

Пример.

//исходный массив
int b[] ={2,1,0,50,30,20,10};
//сортировка  от 0 элемента до 3, сам третий элемент не входит
Arrays.sort(b,0,3);
//результат сортировки
for(int i=0; i<b.length; i++)
System.out.print(b+"  ");  // 0  1  2  50  30  20  10
System.out.println();
 
//сортировка  элементов от 3 до конца массива bb.length
Arrays.sort(b,3,b.length);
for(int i=0; i<b.length; i++)
System.out.print(b+"  "); //0  1  2  10  20  30  50
System.out.println();

 Сортировка  массива по убыванию

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

 Arrays.sort([]a, Collections.reverseOrder());

 При сортировке массива в обратном порядке (по убыванию) нужно использовать вместо примитивного типа, объектный тип.

Пример.

//// сортировrка по убыванию
//вместо примитивного типа double
//используем объектный тип   Double
   Double a[] = new Double;
   //заполняем массив случаными числами
   for(int i = 0; i <  a.length; i++) {
     a =  (double)(Math.random() * 20);
      System.out.format("%.2f   ", a);
         }
System.out.println();  
System.out.println("Массив,отсотированный по убыванию");
//Сортируем массив
    Arrays.sort(a, Collections.reverseOrder());
//Выводим отсортированный массив на консоль.
for(int i = 0; i <  a.length; i++) {
     System.out.format("%.2f   ", a);
     }
System.out.println();  

Результат

15,39   1,54   17,47   15,50   3,83   16,43   18,87   15,54   8,23   12,97  

Массив,отсотированный по убыванию

18,87   17,47   16,43   15,54   15,50   15,39   12,97   8,23   3,83   1,54   

типы массивов в Java

В Java есть 2 типа массивов:

• Одномерный массив — он содержит только 1 строку и 1 столбец. Все приведенные выше примеры относятся к одномерному массиву
• Многомерный массив — содержит несколько строк и несколько столбцов. Другими словами, это массив массивов, в которых все строки имеют одинаковые Число столбцов. Например: 2 * 2 матрица
• Неровный массив — каждая строка содержит разное количество столбцов.

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

Многомерные массивы могут иметь несколько строк и столбцов. Индекс в первом [] представляет строки, а второй [] представляет столбцы.

Например: int [] [] a = new int

Это означает, что массив содержит 2 строки и 3 столбца. Ниже приведено схематическое изображение многомерного массива.

Пример создания многомерных массивов строк

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

public class ArrayMulti {

  public static void main(String[] args) {
    String[][] arrNames = {{"John","Jacob"},{"Thomas","Martin"}};
    System.out.println(arrNames + " " + arrNames);
    System.out.println(arrNames + " " + arrNames);

  }

}

Output:
John Jacob 
Thomas Martin

Пример двумерного массива целых чисел

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

public class ArrayMulti {

  public static void main(String[] args) {
    //Declare and create multidimensional array
    int[][] arrnum = new int;
    for(int i=0;i<2;i++) {
      for(int j=0;j<3;j++) {
        //Assign values to array elements
        arrnum = i+1;
        System.out.print(arrnum + " ");
      }
      System.out.println();
    }

  }

}

Output:
1 1 1 
2 2 2 

Зубчатые массивы в Java

Неровный массив — это также двумерный массив, имеющий другое количество столбцов. Другими словами, каждый строка имеет другое количество столбцов. Инициализация массива с зазубринами отличается от инициализации обычного 2D-массива.

Инициализация массива с зазубринами

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

int[][] arrnum = new int[];
arrnum = new int;
arrnum = new int;

Пример зазубренного массива путем присвоения значений в цикле for

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arrnum = new int[];
    arrnum = new int;
    arrnum = new int;

    int val=1;
    //Assign values
    for(int i=0;i<arrnum.length;i++) {
      for(int j=0;j<arrnum.length;j++) {
        arrnum = val;
      }
    }
    
    //Print the values
    for(int i=0;i<arrnum.length;i++)
    {
      for(int j=0;j<arrnum.length;j++)
      {
        System.out.print(arrnum + " ");
      }
      System.out.println();
    }
  }

}

Output:
1 1 1 
1 1 1 1 

Пример зазубренного массива с инициализацией значений во время создания массива

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arr = {{4,5,6},{1,2},{7,9,8}};
    for(int i=0;i<3;i++)
    {
      for(int j=0;j<arr.length;j++) {
        System.out.print(arr + " ");
      }
      System.out.println();
    }
  }
}

Output:
4 5 6 
1 2 
7 9 8