0Pricing
Java Academy · Lección

LinkedList frente a ArrayList: ventajas y desventajas

Compare el rendimiento de la inserción, eliminación y acceso aleatorio para elegir el tipo de lista adecuado.

LinkedList frente a ArrayList: ventajas y desventajas es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

La cuestión fundamental

Tanto ArrayList como LinkedList implementan List, por lo que comparten la misma API. La diferencia radica en sus estructuras de datos internas y en las operaciones que cada una realiza de forma eficiente.

Aspectos internos de ArrayList

ArrayList almacena los elementos en un array contiguo. Cuando el array se llena, se sustituye por otro 1.5× mayor y se copian todos los elementos.

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>(4); // initial capacity 4
list.add("A"); list.add("B"); list.add("C"); list.add("D");
list.add("E"); // triggers resize: new array of capacity 6

System.out.println(list.get(3)); // O(1) — direct index access

Aspectos internos de LinkedList, revisados

Cada elemento reside en su propio objeto Node, con punteros prev/next. No hay memoria contigua: los nodos pueden estar en cualquier lugar del heap.

import java.util.LinkedList;

LinkedList<String> list = new LinkedList<>();
list.add("A"); list.add("B"); list.add("C");

// get(index) must traverse from head or tail
System.out.println(list.get(1)); // O(n) — traverses 1 step from head

Acceso aleatorio: gana ArrayList

ArrayList.get(i) cuesta O(1): acceso directo mediante el índice del array. LinkedList.get(i) cuesta O(n): recorre hasta n/2 nodos.

ArrayList<Integer> al = new ArrayList<>();
LinkedList<Integer> ll = new LinkedList<>();
for (int i = 0; i < 100_000; i++) { al.add(i); ll.add(i); }

// Fast:
System.out.println(al.get(99_999)); // O(1)

// Slow — avoid this pattern with LinkedList:
System.out.println(ll.get(99_999)); // O(n)

Inserciones al principio: gana LinkedList

Añadir en el índice 0 de ArrayList requiere desplazar todos los elementos, lo que cuesta O(n). LinkedList solo actualiza dos punteros, lo que cuesta O(1).

// ArrayList: O(n) — shifts all elements right
ArrayList<String> al = new ArrayList<>(List.of("B","C","D"));
al.add(0, "A"); // shifts B, C, D

// LinkedList: O(1)
LinkedList<String> ll = new LinkedList<>(List.of("B","C","D"));
ll.addFirst("A"); // updates head pointer only

Inserciones al final: aproximadamente iguales

Tanto ArrayList como LinkedList ofrecen adiciones amortizadas O(1) al final. ArrayList activa ocasionalmente una copia al cambiar de tamaño, pero el coste amortizado sigue siendo O(1). LinkedList asigna un nodo nuevo y no necesita cambiar de tamaño.

ArrayList<Integer> al = new ArrayList<>();
LinkedList<Integer> ll = new LinkedList<>();

for (int i = 0; i < 1_000_000; i++) {
    al.add(i); // amortized O(1)
    ll.add(i); // O(1)
}

Uso de memoria

ArrayList: ~8 bytes por elemento (una referencia en el array). LinkedList: ~48 bytes por elemento (un objeto Node con datos, prev, next y la cabecera del objeto). Para conjuntos de datos grandes, ArrayList utiliza considerablemente menos memoria.

Rendimiento de la iteración

La iteración secuencial (for-each o iterator) cuesta O(n) en ambos casos. Sin embargo, ArrayList se beneficia de la precarga de la caché de la CPU, ya que los elementos son contiguos en memoria. Los nodos de LinkedList están dispersos por el heap, lo que provoca fallos de caché.

// Both O(n), but ArrayList is faster in practice due to cache locality
for (String s : arrayList) { process(s); }
for (String s : linkedList) { process(s); } // more cache misses

Inserción y eliminación en el medio

Ambas requieren O(n) para encontrar la posición. Una vez encontrada, ArrayList desplaza los elementos en O(n), mientras que LinkedList solo desvincula el nodo en O(1). Por tanto, para modificaciones frecuentes en el medio cuando ya tiene un iterador, LinkedList es superior; de lo contrario, son similares.

LinkedList<Integer> ll = new LinkedList<>(List.of(1,2,3,4,5));
ListIterator<Integer> it = ll.listIterator();
while (it.hasNext()) {
    int val = it.next();
    if (val == 3) it.remove(); // O(1) unlink via iterator
}
System.out.println(ll); // [1, 2, 4, 5]

Guía para decidir

Elija según la operación predominante:

  • ArrayList: acceso aleatorio, iteración y adiciones al final; cubre el 90 % de los casos de uso
  • LinkedList: inserciones o eliminaciones frecuentes al principio o al final, e implementación de colas, Deque o pilas
  • ArrayDeque: si necesita una cola o pila pura, es mejor que LinkedList

Resumen de la comparativa de rendimiento

Modelo mental del rendimiento:

  • get(i): ArrayList O(1) frente a LinkedList O(n)
  • add(0,x): ArrayList O(n) frente a LinkedList O(1)
  • add(x): ambos O(1) amortizado
  • iterator remove: ambos O(1) una vez posicionados
  • Memoria por elemento: ArrayList ~8 B frente a LinkedList ~48 B

Comprobación rápida

Está creando una cola de tareas en la que las tareas se añaden al final y se eliminan del principio millones de veces por segundo. ¿Qué estructura de datos es la más adecuada?

Repaso: LinkedList frente a ArrayList

Aspectos clave:

  • ArrayList destaca por el acceso aleatorio (O(1)) y la iteración compatible con la caché
  • LinkedList destaca por las operaciones O(1) en la cabeza y la cola
  • Memoria: ArrayList ~8 B/elemento; LinkedList ~48 B/elemento
  • Para colas y pilas, prefiera ArrayDeque en lugar de LinkedList
  • ArrayList es la opción predeterminada adecuada para la mayoría de los casos

Preguntas frecuentes

¿La lección «LinkedList frente a ArrayList: ventajas y desventajas» es gratis?

Sí — el texto completo de «LinkedList frente a ArrayList: ventajas y desventajas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «LinkedList frente a ArrayList: ventajas y desventajas»?

Compare el rendimiento de la inserción, eliminación y acceso aleatorio para elegir el tipo de lista adecuado. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «LinkedList frente a ArrayList: ventajas y desventajas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Aspectos internos de LinkedList
  2. Operaciones de Deque: pila y cola
  3. LinkedList frente a ArrayList: ventajas y desventajas
  4. PriorityQueue para el procesamiento ordenado
← Volver a Java Academy