Рассматривать:
int[][] multD = new int[5][];
multD[0] = new int[10];
Это как вы создаете двумерный массив с 5 строками и 10 столбцами?
Я видел этот код онлайн, но синтаксис не имел смысла.
Рассматривать:
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 }
};
new int[][]
в =new int[][]{...}
варианте? Мы можем просто написать ={...}
?
new
ключевого слова.
int array[][] = new int[3][];
VS int array[][] = new int[][3];
?? который является законным, поскольку я прочитал обе версии где-нибудь.
Мы можем объявить двумерный массив и напрямую сохранить элементы во время его объявления как:
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];
int array[][] = new int[3][];
VS int array[][] = new int[][3];
?? который является законным, поскольку я прочитал обе версии где-нибудь.
Наиболее распространенная идиома для создания двумерного массива с 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];
}
Object[][] ary2d = new Object[5][10];
то вы все равно должны инициализировать каждый элемент 2D-массива.
null
дело безопасно для любых не примитивов. Нужно ли вам инициализировать каждый элемент, полностью зависит от вашего дизайна. Кроме того, просто для пояснения - примитивы не могут иметь значение null и могут быть созданы для определенного значения по умолчанию, если оно не назначено вами. Например, an int
не может быть нулевым, и когда вы говорите int i;
без присвоения значения, используется значение по умолчанию 0
. Читайте об этом здесь
Пытаться:
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