Синтаксис для создания двумерного массива
Рассматривать:
int[][] multD = new int[5][];
multD[0] = new int[10];
Это как вы создаете двумерный массив с 5 строками и 10 столбцами?
Я видел этот код онлайн, но синтаксис не имел смысла.
13 ответов
Попробуйте следующее:
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
Если вам нужно что-то динамичное и гибкое (т. е. где вы можете добавлять или удалять столбцы и строки), вы можете попробовать "ArrayList of ArrayList":
public static void main(String[] args) {
ArrayList<ArrayList<String>> arrayListOfArrayList = new ArrayList<>();
arrayListOfArrayList.add(new ArrayList<>(List.of("First", "Second", "Third")));
arrayListOfArrayList.add(new ArrayList<>(List.of("Fourth", "Fifth", "Sixth")));
arrayListOfArrayList.add(new ArrayList<>(List.of("Seventh", "Eighth", "Ninth")));
arrayListOfArrayList.add(new ArrayList<>(List.of("Tenth", "Eleventh", "Twelfth")));
displayArrayOfArray(arrayListOfArrayList);
addNewColumn(arrayListOfArrayList);
displayArrayOfArray(arrayListOfArrayList);
arrayListOfArrayList.remove(2);
displayArrayOfArray(arrayListOfArrayList);
}
private static void displayArrayOfArray(ArrayList<ArrayList<String>> arrayListOfArrayList) {
for (int row = 0; row < arrayListOfArrayList.size(); row++) {
for (int col = 0; col < arrayListOfArrayList.get(row).size(); col++) {
System.out.printf("%-10s", arrayListOfArrayList.get(row).get(col));
}
System.out.println("");
}
System.out.println("");
}
private static void addNewColumn(ArrayList<ArrayList<String>> arrayListOfArrayList) {
for (int row = 0; row < arrayListOfArrayList.size(); row++) {
arrayListOfArrayList.get(row).add("added" + row);
}
}
Выход:
First Second Third
Fourth Fifth Sixth
Seventh Eighth Ninth
Tenth Eleventh Twelfth
First Second Third added0
Fourth Fifth Sixth added1
Seventh Eighth Ninth added2
Tenth Eleventh Twelfth added3
First Second Third added0
Fourth Fifth Sixth added1
Tenth Eleventh Twelfth added3