Arrays Unidimensional Y Multidimensional

Arrays unidimensional y multidimensional

Los arrays son una estructura de datos fundamental en Java que se utiliza para almacenar colecciones de elementos del mismo tipo. Un array puede ser unidimensional (una lista simple de elementos) o multidimensional (un conjunto de arrays, como matrices). Vamos a profundizar en cómo funcionan y cómo se utilizan ambos tipos en Java.


1. Arrays Unidimensionales en Java

Un array unidimensional en Java es básicamente una lista de elementos del mismo tipo, accesibles por un índice único. Este tipo de array es el más simple y se usa cuando se necesita almacenar varios valores de un mismo tipo.

Declaración y Creación de un Array Unidimensional

Un array unidimensional puede declararse de dos maneras:

  • Usando corchetes [] después del tipo de dato.
  • Usando la palabra clave new para inicializarlo con un tamaño determinado.

Sintaxis básica:

// Declaración del array
int[] numbers;  // Tipo de datos: int, nombre: numbers

// Creación del array con tamaño especificado
numbers = new int[5];  // Crea un array de 5 elementos

// O bien, declaración y creación en una sola línea
int[] numbers = new int[5];  // Crea un array de 5 elementos

Inicialización de un Array Unidimensional

El array puede inicializarse con valores específicos al momento de su declaración.

Sintaxis para inicialización:

int[] numbers = {1, 2, 3, 4, 5};  // Array con valores iniciales

Acceso a Elementos de un Array Unidimensional

Los elementos de un array unidimensional se acceden utilizando índices. En Java, los índices empiezan desde 0.

Ejemplo de acceso a elementos:

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

// Acceder al primer elemento
System.out.println(numbers[0]);  // Imprime 1

// Acceder al tercer elemento
System.out.println(numbers[2]);  // Imprime 3

Recorrido de un Array Unidimensional

Una forma común de recorrer un array unidimensional es usando un bucle for:

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

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

En este ejemplo, numbers.length devuelve la longitud del array, es decir, el número de elementos que contiene.


2. Arrays Multidimensionales en Java

Un array multidimensional es un array cuyos elementos son a su vez arrays. Este tipo de array se usa para representar estructuras más complejas, como matrices (tablas bidimensionales) o incluso dimensiones más altas.

Arrays Bidimensionales (Matrices)

Un array bidimensional en Java es un array de arrays, en el que cada elemento es a su vez un array. Se puede visualizar como una tabla de filas y columnas.

Declaración y Creación de un Array Bidimensional

Sintaxis para declaración y creación de un array bidimensional:

// Declaración
int[][] matrix;  // array bidimensional de tipo int

// Creación del array bidimensional
matrix = new int[3][4];  // Crea una matriz de 3 filas y 4 columnas

// Declaración y creación en una sola línea
int[][] matrix = new int[3][4];  // Crea una matriz de 3 filas y 4 columnas

Inicialización de un Array Bidimensional

Los arrays bidimensionales también pueden inicializarse directamente con valores, usando llaves anidadas.

Sintaxis de inicialización:

int[][] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

Acceso a Elementos de un Array Bidimensional

Para acceder a los elementos de una matriz, se utilizan dos índices: uno para la fila y otro para la columna.

Ejemplo de acceso a elementos:

int[][] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// Acceder al elemento en la fila 1, columna 2
System.out.println(matrix[1][2]);  // Imprime 7

// Acceder al elemento en la fila 2, columna 3
System.out.println(matrix[2][3]);  // Imprime 12

Recorrido de un Array Bidimensional

Se puede recorrer un array bidimensional utilizando bucles for anidados: uno para las filas y otro para las columnas.

Ejemplo de recorrido:

int[][] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

for (int i = 0; i < matrix.length; i++) {  // Recorre las filas
    for (int j = 0; j < matrix[i].length; j++) {  // Recorre las columnas
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();  // Salto de línea entre filas
}

3. Arrays Multidimensionales de Más de Dos Dimensiones

En Java, es posible tener arrays de más de dos dimensiones, aunque es menos común y se utiliza principalmente en situaciones complejas (como matrices 3D o más).

Un array tridimensional es básicamente un array de arrays de arrays. Su declaración y creación es similar a la de arrays bidimensionales, solo que con más dimensiones.

Ejemplo de Array Tridimensional:

int[][][] array3D = new int[2][3][4];  // Crea un array 3D de 2 "capas", 3 filas y 4 columnas

Acceso a elementos en un array 3D:

array3D[0][1][2] = 10;  // Establece el valor 10 en la capa 0, fila 1, columna 2
System.out.println(array3D[0][1][2]);  // Imprime 10

Recorrido de un Array Tridimensional:

Para recorrer un array tridimensional, se utilizan tres bucles anidados, uno para cada dimensión.

int[][][] array3D = {
    {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    },
    {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
        {21, 22, 23, 24}
    }
};

for (int i = 0; i < array3D.length; i++) {
    for (int j = 0; j < array3D[i].length; j++) {
        for (int k = 0; k < array3D[i][j].length; k++) {
            System.out.print(array3D[i][j][k] + " ");
        }
        System.out.println();
    }
    System.out.println();
}

4. Arrays Jagged (Arrays Irregulares)

Los arrays jagged o irregulares son arrays de arrays en los que las filas no tienen el mismo tamaño. Es decir, cada “sub-array” dentro del array principal puede tener diferentes longitudes.

Declaración e Inicialización de un Array Jagged:

int[][] jaggedArray = new int[3][];  // Array de 3 filas, pero con tamaño no definido aún

// Inicialización de cada fila
jaggedArray[0] = new int[2];  // Fila 0 con 2 elementos
jaggedArray[1] = new int[3];  // Fila 1 con 3 elementos
jaggedArray[2] = new int[4];  // Fila 2 con 4 elementos

Acceso y recorrido:

// Asignación de valores
jaggedArray[0][0] = 1;
jaggedArray[1][1] = 5;
jaggedArray[2][2] = 9;

// Recorrido
for (int i = 0; i < jaggedArray.length; i++) {
    for (int j = 0; j < jaggedArray[i].length; j++) {
        System.out.print(jaggedArray[i][j] + " ");
    }
    System.out.println();
}