Explicación detallada del método Java LinkedList addFirst()

Java LinkedList Java LinkedList

addFirst()SíLinkedListUn método importante en la clase, utilizado para insertar el elemento especificado al comienzo de la lista enlazada.

Sintaxis del método

public void addFirst(E e)

Descripción de parámetros

E e: el elemento que se va a agregar al comienzo de la lista enlazada

Valor de retorno

Este método no tiene valor de retorno (void).

Cómo funciona el método addFirst()

addFirst()El principio de funcionamiento del método se puede describir simplemente como:

  1. Crear un nuevo objeto de nodo (Node)
  2. El puntero del nuevo nodonextapunta al nodo principal actual.
  3. El puntero del nodo principal actualprevapunta al nuevo nodo.
  4. El puntero de la lista enlazadaheadse actualiza para apuntar al nuevo nodo.
  5. Si la lista enlazada estaba vacía, el nodo final (tail) también debe apuntar al nuevo nodo.
  6. Incrementar el contador de tamaño de la lista (size++)

Complejidad temporal

El método addFirst() tiene una complejidad temporal de O(1), porque sin importar el tamaño de la lista, solo necesita realizar una cantidad fija de operaciones.

Ejemplos de uso

Veamos a través de algunos ejemplosaddFirst()el uso específico del método.

Ejemplo 1: Uso básico

Ejemplo

import java.util.LinkedList;

public class AddFirstExample {
    public static void main(String[] args) {
        // Crear un LinkedList
        LinkedList<String> fruits = new LinkedList<>();
       
        // Agregar elementos iniciales
        fruits.add("Banana");
        fruits.add("Orange");
       
        System.out.println("Lista original: " + fruits);  // Salida: [Banana, Orange]
       
        // Usar addFirst() para agregar un elemento al comienzo
        fruits.addFirst("Apple");
       
        System.out.println("Lista después de agregar: " + fruits);  // Salida: [Apple, Banana, Orange]
    }
}

Ejemplo 2: Agregado consecutivo

Ejemplo

import java.util.LinkedList;

public class ContinuousAddFirst {
    public static void main(String[] args) {
        LinkedList<Integer> numbers = new LinkedList<>();
       
        // Usar addFirst() consecutivamente para agregar elementos
        numbers.addFirst(3);
        numbers.addFirst(2);
        numbers.addFirst(1);
       
        System.out.println(numbers);  // Salida: [1, 2, 3]
       
        // Observa la relación entre el orden de inserción y el orden del resultado final
    }
}

Ejemplo 3: Diferencia con el método add()

Ejemplo

import java.util.LinkedList;

public class AddVsAddFirst {
    public static void main(String[] args) {
        LinkedList<String> list1 = new LinkedList<>();
        LinkedList<String> list2 = new LinkedList<>();
       
        // Usar el método add() para agregar elementos
        list1.add("A");
        list1.add("B");
        list1.add("C");
       
        // Usar el método addFirst() para agregar los mismos elementos
        list2.addFirst("C");
        list2.addFirst("B");
        list2.addFirst("A");
       
        System.out.println("Usando add(): " + list1);    // Salida: [A, B, C]
        System.out.println("Usando addFirst(): " + list2); // Salida: [A, B, C]
       
        // Aunque el resultado final es el mismo, el orden de inserción es inverso
    }
}

Notas importantes

Al usaraddFirst()el método, hay que tener en cuenta los siguientes puntos:

1. Diferencia con el método add()

  • add()El método agrega elementos al final de la lista enlazada por defecto.
  • addFirst()El método agrega elementos al comienzo de la lista enlazada.

2. Diferencia con el método offerFirst()

  • addFirst()En una cola con capacidad limitada puede lanzar una excepción.
  • offerFirst()En una cola con capacidad limitada devuelvefalseen lugar de lanzar una excepción.

3. Manejo de valores null

LinkedListPermite agregarnullvalores null, por lo tantoaddFirst(null)es válido.

4. Seguridad de hilos

LinkedListNo es seguro para hilos; si se usa en un entorno multihiloaddFirst(), se requiere sincronización externa.

Escenarios de aplicación práctica

addFirst()El método es especialmente útil en los siguientes escenarios:

1. Implementar una estructura de pila

Dado que una pila es una estructura "último en entrar, primero en salir" (LIFO), se pueden usar addFirst() y removeFirst() para simular las operaciones de una pila.

Ejemplo

LinkedList<String> stack = new LinkedList<>();
stack.addFirst("Task1");  // Apilar
stack.addFirst("Task2");  // Apilar
String top = stack.removeFirst();  // Desapilar, devuelve "Task2"

2. Lista de uso reciente

Al implementar una lista de uso más reciente (MRU), los elementos recién visitados se pueden agregar al comienzo de la lista.

3. Operación de inversión

Agregando elementos uno a uno con addFirst() a una nueva lista, se puede invertir la lista.

Ejemplo

LinkedList<Integer> original = new LinkedList<>(Arrays.asList(1, 2, 3));
LinkedList<Integer> reversed = new LinkedList<>();

for (Integer num : original) {
    reversed.addFirst(num);
}

System.out.println(reversed);  // Salida: [3, 2, 1]

Consideraciones de rendimiento

addFirst()El método enLinkedListLinkedList tiene un muy buen rendimiento, ya que solo necesita:

  1. Crear un nuevo nodo
  2. Ajustar algunos punteros

Sin importar cuán grande sea la lista enlazada, el tiempo de estas operaciones es constante (complejidad O(1)). EstoArrayListdeadd(0, element)contrasta fuertemente con la operación, que requiere mover todos los elementos existentes (complejidad O(n)).

Por lo tanto, si se necesitan agregar elementos con frecuencia al comienzo de la colección,LinkedListes, en comparación,ArrayListuna mejor opción.

Preguntas frecuentes

Q1: ¿addFirst() sobrescribe los elementos existentes?

No,addFirst()simplemente inserta un nuevo elemento al comienzo de la lista enlazada, sin sobrescribir ningún elemento existente.

Q2: Si la lista enlazada está vacía, ¿addFirst() aún funciona?

Sí, si la lista enlazada está vacía,addFirst()el nuevo elemento se convertirá en el primer y único elemento de la lista enlazada.

Q3: ¿Cuál es la diferencia entre addFirst() y push()?

EnLinkedListEn LinkedList,addFirst()ypush()son exactamente el mismo método.push()SimplementeaddFirst()es otro nombre de addFirst(), utilizado para queLinkedListLinkedList pueda usarse como una pila.

Q4: ¿Por qué mi IDE indica que addFirst() es un método de Deque?

PorqueLinkedListLinkedList implementaDequela interfaz Deque,addFirst()addFirst() es en realidadDequeun método definido en la interfaz Deque,LinkedListy LinkedList proporciona su implementación.

Resumen

LinkedListdeaddFirst()El método es una operación eficiente que nos permite insertar elementos al comienzo de la lista enlazada. Comprender este método esLinkedListmuy importante para usar eficazmente LinkedList, especialmente en escenarios donde se necesita insertar elementos con frecuencia al comienzo de la colección.

Repaso de puntos clave:

  • addFirst()Inserta un elemento al comienzo de la lista enlazada
  • Complejidad temporal de O(1)
  • yadd()Los métodos difieren en la posición de inserción.
  • A menudo se usa para implementar estructuras de pila y listas de uso reciente.
  • Requiere sincronización adicional en entornos multihilo.

Mediante el uso razonable deaddFirst()el método, se puede aprovechar al máximoLinkedListla ventaja de rendimiento en escenarios específicos.

Java LinkedList Java LinkedList

Otras extensiones