Artículo

ArrayList en Java: qué es, métodos y diferencias con un array

Cómo usar ArrayList en Java: crear, añadir, obtener, borrar y ordenar elementos, diferencias con un array y los errores más comunes, con ejemplo ejecutable.

En resumen: ArrayList es una lista de tamaño dinámico basada en un array interno. Úsala cuando no sabes cuántos elementos tendrás: crece sola, admite duplicados, mantiene el orden de inserción y accede por índice en tiempo constante. Un array (String[]) tiene tamaño fijo y admite primitivos; una ArrayList solo admite objetos (Integer, no int). Probado con Java 25, compatible desde Java 17.

ArrayList es probablemente la colección que más vas a usar en Java. Aquí tienes sus operaciones principales con la salida real y las trampas que más errores provocan.

Vídeo explicativo

Array frente a ArrayList

Array (String[])ArrayList<String>
TamañoFijo al crearloCrece y decrece solo
TiposPrimitivos y objetosSolo objetos
Longitudarray.lengthlista.size()
Accesoarray[i]lista.get(i)
Métodos útilesPocos (Arrays.*)add, remove, contains, sort…
CuándoTamaño conocido, rendimiento extremo, primitivosCasi siempre

Ejemplo completo

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

public class Main {
    public static void main(String[] args) {
        // Array: tamaño fijo
        String[] array = new String[3];
        array[0] = "Java";
        array[1] = "Spring";
        array[2] = "JPA";
        System.out.println("Array: " + Arrays.toString(array) + ", longitud " + array.length);

        // ArrayList: crece sola
        List<String> lista = new ArrayList<>();
        lista.add("Java");
        lista.add("Spring");
        lista.add("JPA");
        lista.add(1, "Maven");          // inserta en la posición 1
        System.out.println("Lista: " + lista + ", tamaño " + lista.size());

        System.out.println("get(2) = " + lista.get(2));
        lista.set(0, "Java 21");
        System.out.println("contains(\"JPA\") = " + lista.contains("JPA"));
        System.out.println("indexOf(\"Spring\") = " + lista.indexOf("Spring"));

        lista.remove("Maven");          // por valor
        lista.remove(0);                // por índice
        System.out.println("Tras borrar: " + lista);

        List<Integer> numeros = new ArrayList<>(List.of(5, 3, 8, 1));
        Collections.sort(numeros);
        System.out.println("Ordenada: " + numeros);
        numeros.sort(Comparator.reverseOrder());
        System.out.println("Descendente: " + numeros);

        // Trampa: remove(int) borra por índice, remove(Object) por valor
        numeros.remove(Integer.valueOf(8));
        System.out.println("Tras remove(Integer.valueOf(8)): " + numeros);

        // Borrar mientras se recorre: usa removeIf, no un for-each
        numeros.removeIf(n -> n < 3);
        System.out.println("Tras removeIf(n < 3): " + numeros);

        // List.of es inmutable
        List<String> fija = List.of("a", "b");
        try {
            fija.add("c");
        } catch (UnsupportedOperationException e) {
            System.out.println("List.of no admite add: UnsupportedOperationException");
        }
    }
}

Salida:

Array: [Java, Spring, JPA], longitud 3
Lista: [Java, Maven, Spring, JPA], tamaño 4
get(2) = Spring
contains("JPA") = true
indexOf("Spring") = 2
Tras borrar: [Spring, JPA]
Ordenada: [1, 3, 5, 8]
Descendente: [8, 5, 3, 1]
Tras remove(Integer.valueOf(8)): [5, 3, 1]
Tras removeIf(n < 3): [5, 3]
List.of no admite add: UnsupportedOperationException

Métodos principales

MétodoQué haceCoste
add(e)Añade al finalConstante (amortizado)
add(i, e)Inserta en la posición iLineal: desplaza el resto
get(i) / set(i, e)Lee o reemplaza por índiceConstante
remove(i) / remove(o)Borra por índice o por valorLineal
contains(o) / indexOf(o)Busca usando equalsLineal
size() / isEmpty()TamañoConstante
sort(c)Ordena con un Comparatorn·log n
removeIf(p)Borra los que cumplen una condiciónLineal

contains y remove(Object) usan equals: si guardas objetos propios, implementa bien equals y hashCode.

Errores frecuentes

  • remove(1) en una List<Integer> borra el elemento de la posición 1, no el número 1. Para borrar por valor: remove(Integer.valueOf(1)).
  • Modificar la lista dentro de un for-each lanza ConcurrentModificationException. Usa removeIf o un Iterator.
  • Añadir a List.of(...) o Arrays.asList(...). La primera es inmutable; la segunda tiene tamaño fijo. Envuélvelas en new ArrayList<>(...) si necesitas modificarlas.
  • Declarar ArrayList<String> lista. Mejor List<String> lista = new ArrayList<>(): el resto del código depende de la interfaz y puedes cambiar la implementación sin tocarlo.
  • Usarla para búsquedas por clave. Si buscas por identificador, un HashMap es constante; contains en una lista recorre todos los elementos.

Preguntas frecuentes

¿ArrayList o LinkedList?

ArrayList en casi todos los casos: el acceso por índice es constante y aprovecha mejor la caché del procesador. LinkedList solo gana si insertas o borras muchísimo al principio de la lista. Lo comparamos en listas enlazadas en Java.

¿ArrayList es segura con varios hilos?

No. Para concurrencia usa Collections.synchronizedList o, si hay muchas más lecturas que escrituras, CopyOnWriteArrayList.

¿Cómo recorro una ArrayList?

Con un for-each, con forEach y una lambda o con un stream. Tienes todas las opciones en cómo iterar listas en Java.

¿Puedo guardar int en una ArrayList?

No directamente: se guardan Integer y Java convierte automáticamente (autoboxing). Más en la diferencia entre int e Integer.

Sigue aprendiendo

Las colecciones (List, Set, Map) y cuándo usar cada una se trabajan con ejercicios en el curso de Java desde cero. Tienes también la visión general en listas y colecciones en Java.

arraylist java listas colecciones array vs arraylist

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo