Синтаксис для создания двумерного массива

438

Рассматривать:

int[][] multD = new int[5][];
multD[0] = new int[10];

Это как вы создаете двумерный массив с 5 строками и 10 столбцами?

Я видел этот код онлайн, но синтаксис не имел смысла.

AppSensei
источник
да, можно также определить двумерный массив как имеющий 10 столбцов в первом утверждении. int [] [] multD = new int [5] [10];
совершиландройдер

Ответы:

814

Попробуйте следующее:

int[][] multi = new int[5][10];

... это короткая рука для чего-то вроде этого:

int[][] multi = new int[5][];
multi[0] = new int[10];
multi[1] = new int[10];
multi[2] = new int[10];
multi[3] = new int[10];
multi[4] = new int[10];

Обратите внимание , что каждый элемент будет инициализирован значением по умолчанию для int, 0, поэтому приведенные выше, также эквивалентны:

int[][] multi = new int[][]{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
oldrinb
источник
27
Самое интересное, что вы можете иметь разные столбцы в разных строках. Например: - int [] [] multi = new int [5] []; multi [0] = new int [10]; multi [1] = new int [6]; multi [2] = new int [9] также идеально подходит
JavaTec
2
Привет Muneeb, если я правильно понял, вы спрашиваете в многомерном массиве, с различным размером столбца для каждой строки, как назначить значения. Вот как: int [] [] multi = new int [] [] {{1,2,3}, {1,2,3,4}, {1}}; и вы можете получить доступ к ним или распечатать их следующим образом: for (int i = 0; i <multi.length; i ++) {for (int j = 0; j <multi [i] .length; j ++) {System.out.println ( "строка:" + i + "столбец:" + j + "значение:" + multi [i] [j]); }}
JavaTec
1
Нужно ли использовать new int[][]в =new int[][]{...}варианте? Мы можем просто написать ={...}?
Наваз
2
@Nawaz Нет, Массивы - это Объект в Java, и память выделяется для Объектов только с помощью newключевого слова.
roottraveller
1
@ Олдринб, а как насчет int array[][] = new int[3][];VS int array[][] = new int[][3];?? который является законным, поскольку я прочитал обе версии где-нибудь.
roottraveller
77

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

int marks[][]={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};

Здесь int представляет элементы целочисленного типа, хранящиеся в массиве, а имя массива - «mark». int - это тип данных для всех элементов, представленных в фигурных скобках "{" и "}", поскольку массив представляет собой набор элементов, имеющих одинаковый тип данных.

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

Теперь соблюдайте утверждение: вы можете получить 3 строки и 5 столбцов, поэтому JVM создает 3 * 5 = 15 блоков памяти. Эти блоки могут быть индивидуально обозначены как:

marks[0][0]  marks[0][1]  marks[0][2]  marks[0][3]  marks[0][4]
marks[1][0]  marks[1][1]  marks[1][2]  marks[1][3]  marks[1][4]
marks[2][0]  marks[2][1]  marks[2][2]  marks[2][3]  marks[2][4]


ПРИМЕЧАНИЕ.
Если вы хотите сохранить n элементов, индекс массива начинается с нуля и заканчивается n-1 . Другой способ создания двумерного массива - сначала объявить массив, а затем выделить для него память с помощью оператора new.

int marks[][];           // declare marks array
marks = new int[3][5];   // allocate memory for storing 15 elements

Комбинируя вышеперечисленные два, мы можем написать:

int marks[][] = new int[3][5];
Инду Джоши
источник
Я думаю, что это самый разумный способ ввода данных.
thanos.a
51

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

int array[][] = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[5];
Виктор Мукерджи
источник
5
Хорошо сказано! Это наиболее важный аспект независимой инициализации.
Ахамед
@Victor как насчет int array[][] = new int[3][];VS int array[][] = new int[][3];?? который является законным, поскольку я прочитал обе версии где-нибудь.
roottraveller
30

Наиболее распространенная идиома для создания двумерного массива с 5 строками и 10 столбцами:

int[][] multD = new int[5][10];

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

int[][] multD = new int[5][];
for (int i = 0; i < 5; i++) {
  multD[i] = new int[10];
}
Жоао Силва
источник
3
Также следует понимать, что только примитивы не требуют инициализации. Если вы объявляете массив как, Object[][] ary2d = new Object[5][10];то вы все равно должны инициализировать каждый элемент 2D-массива.
Арманд
3
Если вы не обрабатываете nullдело безопасно для любых не примитивов. Нужно ли вам инициализировать каждый элемент, полностью зависит от вашего дизайна. Кроме того, просто для пояснения - примитивы не могут иметь значение null и могут быть созданы для определенного значения по умолчанию, если оно не назначено вами. Например, an intне может быть нулевым, и когда вы говорите int i;без присвоения значения, используется значение по умолчанию 0. Читайте об этом здесь
неделимый
Еще одно уточнение: значения по умолчанию передаются только переменным класса / экземпляра. Локальные переменные (внутри методов) должны быть инициализированы вручную перед использованием.
неразделимо
12

Также можно заявить об этом следующим образом. Это не хороший дизайн, но он работает.

int[] twoDimIntArray[] = new int[5][10];
ctomek
источник
9

Пытаться:

int[][] multD = new int[5][10];

Обратите внимание, что в вашем коде только первая строка 2D-массива инициализируется в 0. Строки со 2 по 5 даже не существуют. Если вы попытаетесь распечатать их, вы получите nullдля каждого из них.

dcernahoschi
источник
8
int [][] twoDim = new int [5][5];

int a = (twoDim.length);//5
int b = (twoDim[0].length);//5

for(int i = 0; i < a; i++){ // 1 2 3 4 5
    for(int j = 0; j <b; j++) { // 1 2 3 4 5
        int x = (i+1)*(j+1);
        twoDim[i][j] = x;
        if (x<10) {
            System.out.print(" " + x + " ");
        } else {
            System.out.print(x + " ");
        }
    }//end of for J
    System.out.println();
}//end of for i
Киран Хортон
источник
8

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

  int array[] = new int[5];

где int - это тип данных, array [] - это объявление массива и new arrayмассив с его объектами с пятью индексами.

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

  int array[][];
  array = new int[3][4];

Вот arrayтип данных int. Сначала я объявил об одномерном массиве этих типов, затем создается массив из 3 строк и 4 столбцов.

В вашем коде

int[][] multD = new int[5][];
multD[0] = new int[10];

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

Zishan
источник
7
int rows = 5;
int cols = 10;

int[] multD = new int[rows * cols];

for (int r = 0; r < rows; r++)
{
  for (int c = 0; c < cols; c++)
  {
     int index = r * cols + c;
     multD[index] = index * 2;
  }
}

Наслаждайтесь!

Albeoris
источник
1
Это было бы полезно на языке, который не поддерживает двумерные массивы, такие как C!
Alaa
3
C также поддерживает многомерные массивы.
Рикардо Крус
4

Попробуйте так:

int a[][] = {{1,2}, {3,4}};

int b[] = {1, 2, 3, 4};
Пиюш Булчандани
источник
3

Эти типы массивов известны как зубчатые массивы в Java:

int[][] multD = new int[3][];
multD[0] = new int[3];
multD[1] = new int[2];
multD[2] = new int[5];

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

 int[][] multD = {{2, 4, 1}, {6, 8}, {7, 3, 6, 5, 1}};

Вы можете легко перебрать все элементы в вашем массиве:

for (int i = 0; i<multD.length; i++) {
    for (int j = 0; j<multD[i].length; j++) {
        System.out.print(multD[i][j] + "\t");
    }
    System.out.println();
}
ritesh9984
источник
0

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

int[][]   ar  = new int[2][];
int[][][] ar  = new int[2][][];
int[][]   ar  = new int[2][2]; // 2x2 array with zeros

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

int[][]   ar  = new int[2][2];
ar[1][3] = 10; // index out of bound
ar[1]    = new int[] {1,2,3,4,5,6}; // works
inmyth
источник