Tutorial Java: Arrays y matrices

Arrays de una dimensión de tipos primitivos y String

En Java, un array (o arreglo) es una estructura de datos que permite almacenar múltiples elementos del mismo tipo en una secuencia ordenada. Se utiliza para almacenar y acceder a un conjunto de valores utilizando un índice numérico.

Para declarar un array unidimensional de un tipo primitivo o de String, se especifica el tipo de datos seguido de corchetes. Por ejemplo, para declarar un array de enteros se escribe int[] miArray;.

Después de la declaración, se debe inicializar el array. Esto se hace asignando una nueva instancia del array con un tamaño específico: miArray = new int[5];. Aquí, se crean cinco posiciones donde se pueden almacenar valores enteros.

También se puede declarar e inicializar el array en una sola línea: int[] miArray = new int[5];.

Para asignar valores a cada posición del array, se utiliza el índice, que comienza en cero. Por ejemplo, miArray[0] = 10; asigna el valor 10 a la primera posición.

De manera similar, se puede acceder a los valores almacenados en el array utilizando el índice: int valor = miArray[0];. Aquí, se está leyendo el valor de la primera posición y asignándolo a la variable valor.

En el caso de arrays de String, la sintaxis es similar. Por ejemplo, String[] nombres = new String[3]; declara e inicializa un array para almacenar tres cadenas de texto.

Se pueden asignar valores al array de String como nombres[0] = "Ana"; y acceder a ellos de la misma forma: String primerNombre = nombres[0];.

Otra forma de inicializar un array es utilizando una lista de valores entre llaves. Por ejemplo, int[] numeros = {1, 2, 3, 4, 5}; crea un array con los valores iniciales especificados.

Esta técnica también se aplica a arrays de String: String[] dias = {"Lunes", "Martes", "Miércoles"};.

El atributo length de un array permite conocer su tamaño. Por ejemplo, int tamaño = numeros.length; asigna a la variable tamaño el tamaño del array numeros.

Es importante recordar que al acceder a elementos del array, si se utiliza un índice fuera de los límites (por ejemplo, negativo o mayor o igual a length), se produce una excepción ArrayIndexOutOfBoundsException.

Los arrays en Java son de tamaño fijo, lo que significa que una vez creados, no se puede cambiar su tamaño. Si se necesita una estructura que permita redimensionamiento, se puede utilizar una colección como ArrayList.

Para mostrar todos los elementos de un array, se puede utilizar un bucle. Por ejemplo:

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

Alternativamente, el bucle for-each facilita la iteración sobre los elementos:

for (int numero : numeros) {
    System.out.println(numero);
}

La clase Arrays del paquete java.util proporciona métodos para trabajar con arrays, como Arrays.toString(array) para obtener una representación en String del array.

Por ejemplo, para imprimir un array completo se puede hacer:

System.out.println(Arrays.toString(numeros));

Es necesario importar la clase Arrays para utilizar sus métodos:

import java.util.Arrays;

Arrays de dos dimensiones de tipos primitivos y String

En Java, los arrays de dos dimensiones permiten representar matrices o tablas de datos, donde cada elemento se accede mediante dos índices: uno para la fila y otro para la columna.

Para declarar un array bidimensional de un tipo primitivo, se utilizan dos pares de corchetes. Por ejemplo, int[][] matriz; declara una variable matriz que puede contener un array de arrays de enteros.

Después de la declaración, se debe inicializar el array especificando el número de filas y columnas. Por ejemplo, matriz = new int[3][4]; crea una matriz con 3 filas y 4 columnas.

También se pueden combinar la declaración y la inicialización en una sola línea: int[][] matriz = new int[3][4]; para simplificar.

Para asignar valores a los elementos de la matriz, se utilizan dos índices. Por ejemplo, matriz[0][0] = 10; asigna el valor 10 al elemento en la primera fila y primera columna.

De manera similar, se puede acceder a los valores almacenados en la matriz utilizando ambos índices: int valor = matriz[0][0]; asigna a valor el elemento en la primera fila y primera columna.

Los arrays bidimensionales de String se declaran e inicializan de la misma manera. Por ejemplo, String[][] tablaNombres = new String[2][3]; crea una tabla para almacenar 2 filas de 3 cadenas cada una, es decir, 2 filas y 3 columnas.

Se pueden asignar valores a la tabla de cadenas como tablaNombres[1][2] = "Carlos"; y acceder a ellos con String nombre = tablaNombres[1][2];.

Una forma alternativa de inicializar un array bidimensional es utilizando listas de valores anidadas. Por ejemplo:

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

En este caso, se crea una matriz con 2 filas y 3 columnas, y se asignan los valores correspondientes a cada posición.

El atributo length puede utilizarse para obtener el número de filas con matriz.length y el número de columnas de una fila específica con matriz[0].length.

Es importante recordar que en Java, los arrays multidimensionales son realmente arrays de arrays, por lo que las filas pueden tener diferentes longitudes, creando matrices irregulares.

Por ejemplo, se puede crear una matriz irregular así:

int[][] matrizIrregular = new int[3][];
matrizIrregular[0] = new int[2];
matrizIrregular[1] = new int[3];
matrizIrregular[2] = new int[1];

En este caso, la primera fila tiene 2 columnas, la segunda tiene 3 y la tercera tiene 1 columna.

Es necesario validar que no se accede a posiciones fuera de los límites para evitar excepciones ArrayIndexOutOfBoundsException.

Al trabajar con matrices irregulares, se debe tener especial cuidado al acceder a las longitudes de cada fila, ya que pueden diferir entre sí.

Iterar sobre arrays

La iteración sobre arrays es una operación que permite acceder y manipular cada uno de los elementos almacenados.

Existen varias formas de iterar sobre arrays, dependiendo del contexto y las necesidades del programa.

Una forma común de iterar sobre arrays unidimensionales es utilizando un bucle for tradicional. Este bucle permite controlar el índice de cada elemento:

int[] numeros = {1, 2, 3, 4, 5};
for (int i = 0; i < numeros.length; i++) {
    System.out.println("Elemento en posición " + i + ": " + numeros[i]);
}

En este ejemplo, se accede a cada elemento del array utilizando el índice i, que va desde 0 hasta numeros.length - 1.

Otra forma más sencilla es utilizar el bucle for-each, que se introdujo para facilitar la iteración sobre colecciones y arrays:

for (int numero : numeros) {
    System.out.println("Número: " + numero);
}

Con el bucle for-each, se recorre automáticamente cada elemento del array, asignándolo a la variable numero en cada iteración.

Cuando se necesitan modificar los elementos del array, hay tener en cuenta que el bucle for-each no permite acceder al índice, por lo que si es necesario, se debe utilizar el bucle for tradicional:

for (int i = 0; i < numeros.length; i++) {
    numeros[i] *= 2; // Duplicar cada valor del array
}

Para arrays bidimensionales, es común utilizar bucles anidados. El bucle exterior recorre las filas y el interior, las columnas:

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

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

En este ejemplo, se itera sobre cada elemento de la matriz, accediendo a ellos mediante los índices i y j, correspondientes a las filas y columnas respectivamente.

También se puede utilizar el bucle for-each para iterar sobre arrays multidimensionales:

for (int[] fila : matriz) {
    for (int elemento : fila) {
        System.out.print(elemento + " ");
    }
    System.out.println();
}

En este caso, fila es cada array unidimensional dentro de la matriz, y elemento representa cada valor dentro de esa fila.

Otra forma de iterar sobre arrays es utilizando la API de Streams. La clase Arrays proporciona el método stream() para convertir un array en un Stream, lo que permite utilizar operaciones funcionales:

import java.util.Arrays;

Arrays.stream(numeros)
      .forEach(numero -> System.out.println("Número: " + numero));

Con los Streams, se pueden realizar operaciones más complejas, como filtrar o transformar los elementos del array de manera concisa:

Arrays.stream(numeros)
      .filter(numero -> numero % 2 == 0)
      .map(numero -> numero * 3)
      .forEach(numero -> System.out.println("Número procesado: " + numero));

En este ejemplo, se filtran los números pares y se les aplica una transformación multiplicándolos por tres.

Para arrays de objetos, como arrays de String, se aplican las mismas técnicas de iteración:

String[] palabras = {"Java", "es", "genial"};
for (String palabra : palabras) {
    System.out.println(palabra);
}

Al iterar sobre arrays hay que tener cuidado de que los índices utilizados estén dentro de los límites del array para evitar excepciones como ArrayIndexOutOfBoundsException.

Además, desde versiones recientes de Java, se pueden utilizar variables de tipo var en los bucles for-each para una sintaxis más limpia:

for (var numero : numeros) {
    System.out.println("Número: " + numero);
}

La palabra clave var permite al compilador inferir el tipo de la variable.

Al iterar sobre arrays, también se puede interrumpir o continuar la iteración utilizando las sentencias break y continue. Por ejemplo, para buscar un elemento específico:

for (int numero : numeros) {
    if (numero == 3) {
        System.out.println("Número encontrado: " + numero);
        break;
    }
}

En este caso, el bucle se interrumpe cuando se encuentra el número 3.

Por otro lado, para omitir ciertos elementos durante la iteración, se utiliza continue:

for (int numero : numeros) {
    if (numero % 2 != 0) {
        continue; // Saltar números impares
    }
    System.out.println("Número par: " + numero);
}

Esto imprimirá solo los números pares del array.