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

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

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

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

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

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

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

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

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

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

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[] twoDimIntArray[] = new int[5][10];

Пытаться:

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

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

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

В 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 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();
}

На самом деле 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