TutorJava Nivel Básico: tutorial completo Java 21

Los arrays son estructuras de datos fundamentales en Java. Las colecciones del Java Collections Framework son más flexibles y son lo que usarás en la mayoría de situaciones reales.

Arrays

Un array tiene tamaño fijo, declarado en el momento de su creación. Los índices empiezan en 0:

// Declaración e inicialización
int[] numeros = new int[5];          // [0, 0, 0, 0, 0]
numeros[0] = 10;
numeros[1] = 20;

// Inicialización directa
String[] frutas = {"manzana", "pera", "naranja"};

// Longitud
System.out.println(frutas.length);   // 3

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

// Arrays multidimensionales (matrices)
int[][] matriz = new int[3][3];
matriz[0][0] = 1;
matriz[1][1] = 5;
matriz[2][2] = 9;

La clase Arrays

java.util.Arrays proporciona utilidades esenciales:

import java.util.Arrays;

int[] arr = {5, 2, 8, 1, 9, 3};
Arrays.sort(arr);                          // [1, 2, 3, 5, 8, 9]
System.out.println(Arrays.toString(arr));  // [1, 2, 3, 5, 8, 9]
int pos = Arrays.binarySearch(arr, 5);     // 3 (índice en el array ordenado)
int[] copia = Arrays.copyOf(arr, 4);       // [1, 2, 3, 5]

ArrayList: array dinámico

ArrayList es un array que crece automáticamente. Es la colección más usada en Java:

import java.util.ArrayList;
import java.util.List;

List nombres = new ArrayList<>();
nombres.add("Ana");
nombres.add("Luis");
nombres.add("Pedro");
nombres.add(1, "Beatriz");            // inserta en posición 1

System.out.println(nombres.size());   // 4
System.out.println(nombres.get(0));   // Ana
nombres.remove("Luis");
nombres.remove(0);                    // elimina por índice

// Iterar
for (String nombre : nombres) {
    System.out.println(nombre);
}

// Verificar existencia
System.out.println(nombres.contains("Pedro")); // true

LinkedList

LinkedList es eficiente para inserciones/eliminaciones en el medio, pero más lenta en acceso por índice. Implementa tanto List como Deque (cola doble):

import java.util.LinkedList;
import java.util.Deque;

Deque pila = new LinkedList<>();
pila.push("primero");
pila.push("segundo");
pila.push("tercero");
System.out.println(pila.pop()); // tercero (LIFO)

Set: sin duplicados

HashSet no permite duplicados y no garantiza orden. LinkedHashSet mantiene el orden de inserción. TreeSet ordena por comparable:

import java.util.HashSet;
import java.util.Set;

Set paises = new HashSet<>();
paises.add("España");
paises.add("Francia");
paises.add("España");  // ignorado, ya existe
System.out.println(paises.size()); // 2

Map: pares clave-valor

HashMap es la implementación más usada. La clave debe implementar correctamente equals y hashCode:

import java.util.HashMap;
import java.util.Map;

Map edades = new HashMap<>();
edades.put("Ana", 30);
edades.put("Luis", 25);
edades.put("Ana", 31);       // sobreescribe el valor de "Ana"

System.out.println(edades.get("Ana"));          // 31
System.out.println(edades.containsKey("Luis")); // true
System.out.println(edades.getOrDefault("Pedro", 0)); // 0 si no existe

// Iterar
for (Map.Entry entry : edades.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}