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

Ответ 1

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

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 }
};

Ответ 2

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

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

Здесь int представляет собой элементы целочисленного типа, хранящиеся в массиве, а имя массива - "метки". 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. Другой способ создания двухмерного массива - сначала объявить массив, а затем выделить для него память с помощью нового оператора.

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

Объединив два выше, мы можем написать:

int marks[][] = new int[3][5];

Ответ 3

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

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

Ответ 4

Наиболее распространенная идиома для создания двумерного массива с 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];
}

Ответ 5

Try:

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

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

Ответ 6

В 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 вы можете выбрать размер столбца для каждой строки, как вы пожелаете.

Ответ 7

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

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

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

Ответ 9

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;
  }
}

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

Ответ 10

Попробуйте этот способ:

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

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

Ответ 11

Эти типы массивов, известные как Jagged Array в Java:

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

В этом случае каждая строка массива содержит разные столбцы. В приведенном выше примере первая строка будет содержать 3 столбца, а вторая строка будет содержать 2 столбца, а 3-я строка содержит 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();
        }