Инициализация многомерного массива в Java

Попробуйте заменить соответствующие строки на:

myStringArray[0][x-1] = "a string";
myStringArray[0][y-1] = "another string";

Ваш код неверен, потому что подмассивы имеют длину y, а индексация начинается с 0. Таким образом, установка myStringArray[0][y] или myStringArray[0][x] завершится ошибкой, поскольку индексы x и y выходят за пределы.

String[][] myStringArray = new String [x][y]; — правильный способ инициализации прямоугольного многомерного массива. Если вы хотите, чтобы он был зазубренным (каждый подмассив потенциально имеет разную длину), вы можете использовать код, аналогичный этот ответ. Однако обратите внимание, что утверждение Джона о том, что вам нужно создавать подмассивы вручную, неверно в случае, когда вам нужен идеально прямоугольный многомерный массив.

В Java нет «настоящих» многомерных массивов.

Например, arr[i][j][k] эквивалентно ((arr[i])[j])[k]. Другими словами, arr — это просто массив массивов, массивов.

Итак, если вы знаете, как работают массивы, вы знаете, как работают многомерные массивы!

Декларация:

int[][][] threeDimArr = new int[4][5][6];

или, с инициализацией:

int[][][] threeDimArr = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };

Доступ:

int x = threeDimArr[1][0][1];

or

int[][] row = threeDimArr[1];

Строковое представление:

Arrays.deepToString(threeDimArr);

урожаи

"[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]"

Полезные статьи

• Java: инициализация многомерного массива
• Java: матрицы и многомерные массивы

Вы также можете использовать следующую конструкцию:

String[][] myStringArray = new String [][] { { "X0", "Y0"},
                                             { "X1", "Y1"},
                                             { "X2", "Y2"},
                                             { "X3", "Y3"},
                                             { "X4", "Y4"} };

Вы можете объявить многомерные массивы, например:

// 4 x 5 String arrays, all Strings are null
// [0] -> [null,null,null,null,null]
// [1] -> [null,null,null,null,null]
// [2] -> [null,null,null,null,null]
// [3] -> [null,null,null,null,null]

String[][] sa1 = new String[4][5];
for(int i = 0; i < sa1.length; i++) {           // sa1.length == 4
    for (int j = 0; j < sa1[i].length; j++) {     //sa1[i].length == 5
        sa1[i][j] = "new String value";
    }
}


// 5 x 0  All String arrays are null
// [null]
// [null]
// [null]
// [null]
// [null]
String[][] sa2 = new String[5][];
for(int i = 0; i < sa2.length; i++) {
    String[] anon = new String[ /* your number here */];
    // or String[] anon = new String[]{"I'm", "a", "new", "array"};
    sa2[i] = anon;
}

// [0] -> ["I'm","in","the", "0th", "array"]
// [1] -> ["I'm", "in", "another"]
String[][] sa3 = new String[][]{ {"I'm","in","the", "0th", "array"},{"I'm", "in", "another"}};

Многомерный массив в Java

Возврат многомерного массива

Java действительно не поддерживает многомерные массивы. В Java двумерный массив — это просто массив массивов, трехмерный массив — это массив массивов массивов, четырехмерный массив — это массив массивов массивов массивов и так далее…

Мы можем определить двумерный массив как:

1. int[ ] num[ ] = {{1,2}, {1,2}, {1,2}, {1,2}}

2. int[ ][ ] num = new int[4][2]

   num[0][0] = 1;
   num[0][1] = 2;
   num[1][0] = 1;
   num[1][1] = 2;
   num[2][0] = 1;
   num[2][1] = 2;
   num[3][0] = 1;
   num[3][1] = 2;
   

   Если не выделять, скажем, num[2][1], то он не инициализируется и тогда ему автоматически выделяется 0, то есть автоматически num[2][1] = 0;

3. Ниже num1.length дает вам строки.

4. В то время как num1[0].length дает вам количество элементов, связанных с num1[0]. Здесь num1[0] имеет связанные массивы только num1[0][0] и num[0][1].

5. Здесь мы использовали цикл for, который помогает нам вычислить num1[i].length. Здесь i увеличивается в цикле.

   class array
   {
       static int[][] add(int[][] num1,int[][] num2)
       {
           int[][] temp = new int[num1.length][num1[0].length];
           for(int i = 0; i<temp.length; i++)
           {
               for(int j = 0; j<temp[i].length; j++)
               {
                   temp[i][j] = num1[i][j]+num2[i][j];
               }
           }
           return temp;
       }
   
       public static void main(String args[])
       {
           /* We can define a two-dimensional array as
                1.  int[] num[] = {{1,2},{1,2},{1,2},{1,2}}
                2.  int[][] num = new int[4][2]
                    num[0][0] = 1;
                    num[0][1] = 2;
                    num[1][0] = 1;
                    num[1][1] = 2;
                    num[2][0] = 1;
                    num[2][1] = 2;
                    num[3][0] = 1;
                    num[3][1] = 2;
   
                    If you don't allocate let's say num[2][1] is
                    not initialized, and then it is automatically
                    allocated 0, that is, automatically num[2][1] = 0;
                 3. Below num1.length gives you rows
                 4. While num1[0].length gives you number of elements
                    related to num1[0]. Here num1[0] has related arrays
                    num1[0][0] and num[0][1] only.
                 5. Here we used a 'for' loop which helps us to calculate
                    num1[i].length, and here i is incremented through a loop.
           */
           int num1[][] = {{1,2},{1,2},{1,2},{1,2}};
           int num2[][] = {{1,2},{1,2},{1,2},{1,2}};
   
           int num3[][] = add(num1,num2);
           for(int i = 0; i<num1.length; i++)
           {
               for(int j = 0; j<num1[j].length; j++)
                   System.out.println("num3[" + i + "][" + j + "]=" + num3[i][j]);
           }
       }
   }
   

Я добавлю, что если вы хотите прочитать размеры, вы можете сделать это:

int[][][] a = new int[4][3][2];

System.out.println(a.length);  // 4
System.out.println(a[0].length); // 3
System.out.println(a[0][0].length); //2

У вас также могут быть нечеткие массивы, в которых разные строки имеют разную длину. , так что a[0].length != a[1].length.

 int[][] myNums = { {1, 2, 3, 4, 5, 6, 7}, {5, 6, 7, 8, 9, 10, 11} };
 for (int x = 0; x < myNums.length; ++x) {
    for(int y = 0; y < myNums[i].length; ++y) {
       System.out.print(myNums[x][y]);
    }
 }

Выход

1 2 3 4 5 6 7 5 6 7 8 9 10 11