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

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

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 блоков памяти. Эти блоки можно индивидуально назвать ta как:

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

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

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

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

попробуй:

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

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

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

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

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

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

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

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

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

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

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

эти типы массивов известны как зубчатые массивы в 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();
}