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

Ответ 1

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

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]; - это правильный способ инициализации прямоугольного многомерного массива. Если вы хотите, чтобы он был зазубрен (каждый подматрица потенциально имеет разную длину), вы можете использовать код, похожий на этот ответ. Обратите внимание, однако, что утверждение Джона о том, что вы должны создать подмассивы вручную, неверно в том случае, если вы хотите идеально прямоугольный многомерный массив.

Ответ 2

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

или

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

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

Arrays.deepToString(threeDimArr);

дает

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

Ответ 3

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

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

Ответ 4

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

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

Ответ 5

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

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

Java не поддерживает true многомерные массивы. В Java двумерный массив представляет собой просто массив массивов, трехмерный массив представляет собой массив массивов массивов, четырехмерный массив представляет собой массив массивов массивов массивов и т.д....

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

• int[ ] num[ ] = {{1,2}, {1,2}, {1,2}, {1,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;

• Ниже num1.length выдает строки.

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

• Здесь мы использовали цикл 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 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]);
          }
      }
  }
  

Ответ 6

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

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.

Ответ 7

Вы можете посмотреть на это, чтобы начать:

    int [][][] i = {                //third dimension curly brace
                     {               // second dimension curly brace
                        {            //first dimension curly brace
                           1,1,1    //elements
                        },           
                    {3,3,3},    
                    {2,2,2}     
                      },
                      {
                         {
                          1,1,1
                         },
                         {3,3,3},
                         {2,2,2}
                       }
                    };