ArrayList en Java: crear, añadir, eliminar, recorrer y ordenar

Una lista que se redimensiona sola

Un array normal de Java tiene una longitud fija: si decides diez huecos, tendrás diez huecos para siempre. ArrayList es la alternativa redimensionable de java.util: crece a medida que añades y se reduce a medida que eliminas, y trae métodos prácticos para lo que realmente haces con una lista.

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

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Ada");
        names.add("Boris");
        names.add("Chen");

        System.out.println(names);
        System.out.println("Count: " + names.size());
    }
}

Fíjate en el tipo entre paréntesis angulares - List<String> - que le dice al compilador que esta lista contiene valores String. El <> (el "diamante") de la derecha permite a Java inferir el mismo tipo sin repetirlo. Y observa que importas java.util.ArrayList; no está disponible por defecto.

Declara como List, construye como ArrayList

Casi siempre verás la variable declarada con la interfaz List en lugar del ArrayList concreto:

List<String> names = new ArrayList<>();

Es una buena costumbre, no una regla. Programar contra la interfaz List significa que al resto de tu código no le importa qué implementación de lista usaste, así que puedes cambiarla por otra más adelante sin tocarlo. Para el uso diario, ambas se comportan igual.

Añadir, obtener y modificar

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");      // añade al final
        fruits.add("banana");
        fruits.add(1, "cherry");  // inserta en el índice 1

        System.out.println(fruits.get(0));   // lee por índice
        fruits.set(0, "apricot");            // sobrescribe el índice 0

        System.out.println(fruits);
    }
}

• add(value) añade al final.
• add(index, value) inserta en una posición, desplazando los elementos posteriores hacia la derecha.
• get(index) lee el elemento en una posición (empezando en cero).
• set(index, value) sobrescribe un elemento existente.

Los índices empiezan en cero, y get sobre un índice fuera de rango lanza IndexOutOfBoundsException.

Eliminar elementos

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");

        fruits.remove("banana");  // elimina por valor (primera coincidencia)
        fruits.remove(0);         // elimina por índice

        System.out.println(fruits);
    }
}

Hay una trampa clásica cuando la lista contiene Integer. remove(int) es "eliminar por índice" y remove(Object) es "eliminar por valor", así que:

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30));
nums.remove(1);                      // elimina el índice 1 -> el valor 20
nums.remove(Integer.valueOf(20));    // elimina el valor 20

Envuelve el valor en Integer.valueOf(...) cuando quieras decir "elimina este valor" y no "elimina este índice".

Tamaño, contains y búsquedas de índice

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        System.out.println(fruits.size());            // 3
        System.out.println(fruits.isEmpty());         // false
        System.out.println(fruits.contains("banana")); // true
        System.out.println(fruits.indexOf("cherry"));  // 2
    }
}

List.of(...) crea rápidamente una lista inmutable; pasarla al constructor de ArrayList te da una copia mutable inicializada con esos valores.

Recorrer un ArrayList

El bucle más limpio es el for mejorado (el "for-each"):

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (String fruit : fruits) {
            System.out.println(fruit.toUpperCase());
        }
    }
}

Cuando también necesitas el índice, usa un bucle contado con size() y get(i):

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (int i = 0; i < fruits.size(); i++) {
            System.out.println(i + ": " + fruits.get(i));
        }
    }
}

Una regla: no añadas ni elimines elementos de una lista mientras un bucle for-each la está recorriendo; eso lanza ConcurrentModificationException. Para borrar elementos que coincidan de forma segura, usa removeIf:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // descarta los números pares
        System.out.println(nums);
    }
}

Ordenar

Collections.sort ordena una lista en el sitio usando el orden natural (alfabético para cadenas, numérico para números):

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(3, 1, 4, 1, 5, 9, 2, 6));

        Collections.sort(nums);
        System.out.println(nums);

        nums.sort(Collections.reverseOrder());  // descendente
        System.out.println(nums);
    }
}

Para órdenes personalizados, pasa un Comparator a list.sort(...); por ejemplo names.sort(Comparator.comparingInt(String::length)) para ordenar por longitud.

ArrayList contiene objetos, no primitivos

No puedes escribir ArrayList<int>. Los genéricos solo funcionan con tipos de objeto, así que usa la clase envoltorio Integer, Double, Boolean, etc.:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> scores = new ArrayList<>();
        scores.add(95);   // el int 95 se autoboxea a Integer
        scores.add(88);

        int first = scores.get(0);  // se auto-desempaqueta de vuelta a int
        System.out.println(first + scores.get(1));
    }
}

El autoboxing de Java convierte por ti entre int e Integer, así que esto se lee de forma natural; solo recuerda que la propia lista almacena objetos Integer.

Siguiente: HashMap

ArrayList es la herramienta adecuada cuando te importa el orden y la posición. Cuando necesitas buscar cosas por una clave - un nombre de usuario a un usuario, un código de producto a un precio - quieres un HashMap, que es la siguiente página.