Sintaxis para crear una matriz bidimensional

Considerar:

int[][] multD = new int[5][];
multD[0] = new int[10];

¿Es así como creas una matriz bidimensional con 5 filas y 10 columnas?

Vi este código en línea, pero la sintaxis no tenía sentido.

Intenta lo siguiente:

int[][] multi = new int[5][10];

... que es una mano corta para algo como esto:

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

Tenga en cuenta que cada elemento se inicializará al valor predeterminado para int, por 0lo que lo anterior también es equivalente a:

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

Podemos declarar una matriz bidimensional y almacenar elementos directamente en el momento de su declaración como:

int marks[][]={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};

Aquí int representa elementos de tipo entero almacenados en la matriz y el nombre de la matriz es 'marcas'. int es el tipo de datos para todos los elementos representados dentro de las llaves "{" y "}" porque una matriz es una colección de elementos que tienen el mismo tipo de datos.

Volviendo a nuestra declaración escrita anteriormente: cada fila de elementos debe escribirse dentro de las llaves. Las filas y los elementos en cada fila deben estar separados por comas.

Ahora observe la declaración: puede obtener 3 filas y 5 columnas, por lo que la JVM crea 3 * 5 = 15 bloques de memoria. Estos bloques se pueden denominar individualmente como:

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]

NOTA:
Si desea almacenar n elementos, el índice de la matriz comienza desde cero y termina en n-1 . Otra forma de crear una matriz bidimensional es declarar la matriz primero y luego asignarle memoria utilizando un nuevo operador.

int marks[][];           // declare marks array
marks = new int[3][5];   // allocate memory for storing 15 elements

Al combinar los dos anteriores podemos escribir:

int marks[][] = new int[3][5];

Puede crearlos tal como lo han mencionado otros. Un punto más para agregar: incluso puede crear una matriz bidimensional sesgada con cada fila, no necesariamente con el mismo número de columnas, como esta:

int array[][] = new int[3][];
array[0] = new int[3];
array[1] = new int[2];
array[2] = new int[5];

El idioma más común para crear una matriz bidimensional con 5 filas y 10 columnas es:

int[][] multD = new int[5][10];

_{Alternativamente, puede usar lo siguiente, que es más similar a lo que tiene, aunque necesita inicializar explícitamente cada fila:}

int[][] multD = new int[5][];
for (int i = 0; i < 5; i++) {
  multD[i] = new int[10];
}

También es posible declararlo de la siguiente manera. No es un buen diseño, pero funciona.

int[] twoDimIntArray[] = new int[5][10];

Tratar:

int[][] multD = new int[5][10];

Tenga en cuenta que en su código solo la primera línea de la matriz 2D se inicializa a 0. Las líneas 2 a 5 ni siquiera existen. Si intenta imprimirlos, obtendrá nullpara todos ellos.

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

En Java, una matriz bidimensional puede declararse igual que una matriz unidimensional. En una matriz unidimensional puedes escribir como

  int array[] = new int[5];

donde int es un tipo de datos, array [] es una declaración de matriz y new arrayes una matriz con sus objetos con cinco índices.

De esa manera, puede escribir una matriz bidimensional de la siguiente manera.

  int array[][];
  array = new int[3][4];

Aquí arrayhay un tipo de datos int. En primer lugar, he declarado en una matriz unidimensional de ese tipo, luego se crea una matriz de 3 filas y 4 columnas.

En su código

int[][] multD = new int[5][];
multD[0] = new int[10];

significa que ha creado una matriz bidimensional, con cinco filas. En la primera fila hay 10 columnas. En Java, puede seleccionar el tamaño de columna para cada fila que desee.

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

¡Disfrutar!

Intenta de esta manera:

int a[][] = {{1,2}, {3,4}};

int b[] = {1, 2, 3, 4};

Estos tipos de matrices se conocen como matrices irregulares en Java:

int[][] multD = new int[3][];
multD[0] = new int[3];
multD[1] = new int[2];
multD[2] = new int[5];

En este escenario, cada fila de la matriz contiene el número diferente de columnas. En el ejemplo anterior, la primera fila tendrá tres columnas, la segunda fila tendrá dos columnas y la tercera fila tendrá cinco columnas. Puede inicializar esta matriz en tiempo de compilación como a continuación:

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

Puede iterar fácilmente todos los elementos en su matriz:

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();
}

En realidad, Java no tiene una matriz multidimensional en sentido matemático. Lo que Java tiene es solo una matriz de matrices, una matriz donde cada elemento también es una matriz. Es por eso que el requisito absoluto para inicializarlo es el tamaño de la primera dimensión. Si se especifican los demás, creará una matriz con el valor predeterminado.

int[][]   ar  = new int[2][];
int[][][] ar  = new int[2][][];
int[][]   ar  = new int[2][2]; // 2x2 array with zeros

También nos da una peculiaridad. El tamaño de la submatriz no se puede cambiar agregando más elementos, pero podemos hacerlo asignando una nueva matriz de tamaño arbitrario.

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