Рассмотрим:
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 представляет элементы целочисленного типа, хранящиеся в массиве, а имя массива - 'marks'. 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];
}
Можно также объявить его следующим образом. Это's не хороший дизайн, но это работает.
int[] twoDimIntArray[] = new int[5][10];
Попробуйте:
int[][] multD = new int[5][10];
Обратите внимание, что в вашем коде только первая строка двумерного массива инициализируется в 0.
Строки со 2 по 5 даже не существуют. Если вы попытаетесь вывести их, то получите null
для каждой из них.
В Java двумерный массив может быть объявлен как одномерный массив. В одномерный массив можно записать как
int array[] = new int[5];
где int-это тип данных, массив [] - это объявление массива, и массив-это массив с объектами с помощью пяти индексов.
Вроде этого, вы можете написать двумерный массив следующим образом.
int array[][];
array = new int[3][4];
Здесь массив-это тип данных int. Я сначала объявили на одномерный массив этого типа, потом создали 3 строки и 4 столбца массива.
В коде
int[][] multD = new int[5][];
multD[0] = new int[10];
означает, что вы создали двумерный массив, с пятью строками. В в первой строке есть 10 столбцов. В Java вы можете выбрать размер столбца для каждой строки, как вы хотите.
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 a[][] = {{1,2}, {3,4}};
int b[] = {1, 2, 3, 4};
Эти типы массивов известны как Jagged массивы в 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();
}