Una array con más de una dimensión se conoce como array multidimensional . Las arrays multidimensionales más utilizadas son las arrays 2D y 3D. Podemos decir que cualquier array de mayor dimensión es básicamente una array de arrays. Un ejemplo muy común de una array 2D es el tablero de ajedrez. Un tablero de ajedrez es una cuadrícula que contiene 64 casillas cuadradas de 1×1. De manera similar, puede visualizar una array 2D. En una array 2D, cada elemento está asociado con un número de fila y un número de columna. Acceder a cualquier elemento de la array 2D es similar a acceder al registro de un archivo de Excel utilizando tanto el número de fila como el número de columna. Las arrays 2D son útiles al implementar un juego de tres en raya, ajedrez o incluso almacenar los píxeles de la imagen.
Declaración de la array 2-D en Java:
Cualquier array bidimensional se puede declarar de la siguiente manera:
Sintaxis:
data_type array_name[][]; (OR) data_type[][] array_name;
- data_type: Dado que Java es un lenguaje de tipo estático (es decir, espera que sus variables se declaren antes de que se les puedan asignar valores). Entonces, especificar el tipo de datos decide el tipo de elementos que aceptará. por ejemplo, para almacenar valores enteros únicamente, el tipo de datos se declarará como int.
- array_name: Es el nombre que se le da a la array 2-D. ej. asignaturas, alumnos, frutas, departamento, etc.
Nota: Podemos escribir [ ][ ] después de tipo_datos o podemos escribir [ ][ ] después de nombre_arreglo al declarar el arreglo 2D.
Java
// java program showing declaration of arrays
import java.io.*;
class GFG {
public static void main(String[] args)
{
int[][] integer2DArray; // 2D integer array
String[][] string2DArray; // 2D String array
double[][] double2DArray; // 2D double array
boolean[][] boolean2DArray; // 2D boolean array
float[][] float2DArray; // 2D float array
double[][] double2DArray; // 2D double array
}
}
Inicialización de array 2-D en Java:
data_type[][] array_Name = new data_type[no_of_rows][no_of_columns];
El total de elementos en cualquier array 2D será igual a (no_of_rows) * (no_of_columns).
- no_of_rows: el número de filas en una array. por ejemplo, no_of_rows = 3, entonces la array tendrá tres filas.
- no_of_columns: El número de columnas en una array. por ejemplo, no_of_columns = 4, entonces la array tendrá cuatro columnas.
La sintaxis anterior de inicialización de arrays asignará valores predeterminados a todos los elementos de la array de acuerdo con el tipo de datos especificado.
Veamos varios enfoques para inicializar arreglos 2D:
Enfoque 1:
Java
// java program to initialize a 2D array
import java.io.*;
class GFG {
public static void main(String[] args)
{
// Declaration along with initialization
// 2D integer array with 5 rows and 3 columns
// integer array elements are initialized with 0
int[][] integer2DArray = new int[5][3];
System.out.println(
"Default value of int array element: "
+ integer2DArray[0][0]);
// 2D String array with 4 rows and 4 columns
// String array elements are initialized with null
String[][] string2DArray = new String[4][4];
System.out.println(
"Default value of String array element: "
+ string2DArray[0][0]);
// 2D boolean array with 3 rows and 5 columns
// boolean array elements are initialized with false
boolean[][] boolean2DArray = new boolean[4][4];
System.out.println(
"Default value of boolean array element: "
+ boolean2DArray[0][0]);
// 2D char array with 10 rows and 10 columns
// char array elements are initialized with
// '\u0000'(null character)
char[][] char2DArray = new char[10][10];
System.out.println(
"Default value of char array element: "
+ char2DArray[0][0]);
// First declaration and then initialization
int[][] arr; // declaration
// System.out.println("arr[0][0]: "+ arr[0][0]);
// The above line will throw an error, as we have
// only declared the 2D array, but not initialized
// it.
arr = new int[5][3]; // initialization
System.out.println("arr[0][0]: " + arr[0][0]);
}
}
Nota: Cuando inicializa una array 2D, siempre debe especificar la primera dimensión (cantidad de filas), pero se puede omitir proporcionar la segunda dimensión (cantidad de columnas).
En el fragmento de código a continuación, no hemos especificado el número de columnas. Sin embargo, el compilador de Java es lo suficientemente inteligente como para manipular el tamaño comprobando el número de elementos dentro de las columnas.
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
// The line below will throw an error, as the first
// dimension(no. of rows) is not specified
int[][] arr = new int[][3];
// The line below will execute without any error, as
// the first dimension(no. of rows) is specified
int[][] arr = new int[2][];
}
}
Puede acceder a cualquier elemento de una array 2D usando números de fila y números de columna.
Enfoque 2:
En el fragmento de código a continuación, no hemos especificado el número de filas y columnas. Sin embargo, el compilador de Java es lo suficientemente inteligente como para manipular el tamaño comprobando el número de elementos dentro de las filas y columnas.
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
String[][] subjects = {
{ "Data Structures & Algorithms",
"Programming & Logic", "Software Engineering",
"Theory of Computation" }, // row 1
{ "Thermodynamics", "Metallurgy",
"Machine Drawing",
"Fluid Mechanics" }, // row2
{ "Signals and Systems", "Digital Electronics",
"Power Electronics" } // row3
};
System.out.println(
"Fundamental Subject in Computer Engineering: "
+ subjects[0][0]);
System.out.println(
"Fundamental Subject in Mechanical Engineering: "
+ subjects[1][3]);
System.out.println(
"Fundamental Subject in Electronics Engineering: "
+ subjects[2][1]);
}
}
Enfoque 3:
Además, podemos inicializar cada elemento de la array por separado. Mira el fragmento de código a continuación:
Java
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
int[][] scores = new int[2][2];
// Initializing array element at position[0][0],
// i.e. 0th row and 0th column
scores[0][0] = 15;
// Initializing array element at position[0][1],
// i.e. 0th row and 1st column
scores[0][1] = 23;
// Initializing array element at position[1][0],
// i.e. 1st row and 0th column
scores[1][0] = 30;
// Initializing array element at position[1][1],
// i.e. 1st row and 1st column
scores[1][1] = 21;
// printing the array elements individually
System.out.println("scores[0][0] = "
+ scores[0][0]);
System.out.println("scores[0][1] = "
+ scores[0][1]);
System.out.println("scores[1][0] = "
+ scores[1][0]);
System.out.println("scores[1][1] = "
+ scores[1][1]);
// printing 2D array using Arrays.deepToString() method
System.out.println(
"Printing 2D array using Arrays.deepToString() method: ");
System.out.println(Arrays.deepToString(scores));
}
}
Enfoque 4
Usar el enfoque anterior para la inicialización de arrays sería una tarea tediosa si el tamaño de la array 2D es demasiado grande. La forma eficiente es usar for loop para inicializar los elementos de la array en el caso de una gran array 2D.
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
int rows = 80, columns = 5;
int[][] marks = new int[rows][columns];
// initializing the array elements using for loop
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
marks[i][j] = i + j;
}
}
// printing the first three rows of marks array
System.out.println("First three rows are: ");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < columns; j++) {
System.out.printf(marks[i][j] + " ");
}
System.out.println();
}
}
}
Podemos usar arr. length se puede usar para encontrar el tamaño de las filas (primera dimensión), y arr[0].length se puede usar para encontrar el tamaño de las columnas (segunda dimensión).
Enfoque 5: (arrays irregulares)
Puede haber un escenario determinado en el que desee que cada fila tenga un número diferente de columnas. Este tipo de arreglo se llama arreglo irregular .
Java
import java.io.*;
class GFG {
public static void main(String[] args)
{
// declaring a 2D array with 2 rows
int jagged[][] = new int[2][];
// not specifying the 2nd dimension,
// and making it as jagged array
// first row has 2 columns
jagged[0] = new int[2];
// second row has 2 columns
jagged[1] = new int[4];
// Initializing the array
int count = 0;
for (int i = 0; i < jagged.length; i++) {
// remember to use jagged[i].length instead of
// jagged[0].length, since every row has
// different number of columns
for (int j = 0; j < jagged[i].length; j++) {
jagged[i][j] = count++;
}
}
// printing the values of 2D Jagged array
System.out.println("The values of 2D jagged array");
for (int i = 0; i < jagged.length; i++) {
for (int j = 0; j < jagged[i].length; j++)
System.out.printf(jagged[i][j] + " ");
System.out.println();
}
}
}
Implementación:
Veamos un programa simple para agregar dos arreglos 2D:
Java
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
int[][] arr1 = { { 1, 2, 3 }, { 4, 5, 6 } };
int[][] arr2 = { { 4, 5, 6 }, { 1, 3, 2 } };
int[][] sum = new int[2][3];
// adding two 2D arrays element-wise
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[0].length; j++) {
sum[i][j] = arr1[i][j] + arr2[i][j];
}
}
System.out.println("Resultant 2D array: ");
for (int i = 0; i < sum.length; i++) {
System.out.println(Arrays.toString(sum[i]));
}
}
}
Publicación traducida automáticamente
Artículo escrito por girishthatte y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA