Uso de Peek PeekFirst y PeekLast en LinkedList

En este artículo vamos a ver el uso de Peek PeekFirst y PeekLast en LinkedList. La clase LinkedList nos ofrece una serie de funcionalidades para poder mirar el primer elemento o el último. Es una útil herramienta cuando no necesitamos hacer operaciones de eliminación.

El uso de LinkedList va a ser muy útil cuando queramos recuperar un elemento de la cabeza o de la cola de una lista, ya que para esos casos su acceso será O(1). Pero en cambio si queremos recuperar un elemento que se encuentra en una posición diferente a la primera o última el acceso a este elemento será O(n).

LinekedList nos ofrece tres funcionalidades para recuperar sus elementos primero y último, vamos a echar un vistazo:

Uso de Peek en una LinkedList

El uso de Peek nos va a devolver el primer elemento de la lista, pero no lo elimina. En el caso de que no existan elementos devolverá null.

import java.util.*;
public class LinkedPeek {
  
public static void main(String[] args) {


        LinkedList listPeek = new LinkedList();

        listPeek.add("Peek");
        listPeek.add("Refactorizando");
        listPeek.add("First");

        System.out.println("The head is : " + listPeek.peek());
    }
}

Resultado:

The head is : Peek

PeekFirst en LinkedList

El método PeekFirst de LinkedList funciona de una manera similar a Peek, devuelve el primer elemento que tenemos en la lista, pero si eliminarlo. Y en el caso que no tengamos elementos devolverá null.

public class LinkedPeekFirst {
  
public static void main(String[] args)
    {
        LinkedList list = new LinkedList();
  
        list.add("Peek");
        list.add("Refactorizando");
        list.add("First");

        System.out.println("First element is : " + list.peekFirst());
    }
}

Resultado:

First element is : Peek

Uso de PeekLast en LinkedList

PeekLast nos va a devolver el último elemento de una lista, sin eliminarlo de la lista. En el caso en el que la lista se encuentre vacía devolverá un null.

public class LinkedPeekLast {
  
public static void main(String[] args)
    {
        LinkedList listPeekLast = new LinkedList();
  
        list.add("Peek");
        list.add("Refactorizando");
        list.add("Last");
  
        System.out.println("Last element is : " + listPeekLast.peekLast());
    }
}

Resultado:

Last element is : Last

¿Cuándo usar LinkedList?

El uso de LinkedList será perfecto para aquellas ocasiones en las que únicamente necesitemos obtener el primero o el último elemento, en otro caso sería mejor hacer uso de ArrayList.

Vamos a ver una comparación de las Big O Notation de un ArrayList y un LinkedList:

LinkedList Big O notation

• get(int index) es O(n), en cambio O(1) cuando index = 0 o index = list.size() - 1. En estos casos es perfecto, usar LinkedList, es el principal beneficio de LinkedList<E>.
• add(int index, E element) es O(n), en cambio  O(1) si index = 0 or index = list.size() - 1 (en este caso, podemos usar addFirst() y addLast()/add()). Uno de los principales beneficios de LinkedList<E>
• remove(int index) es O(n), en cambio O(1) si index = 0 or index = list.size() - 1 (en este caso podemos usar removeFirst() and removeLast()). Uno de los principales beneficios de  LinkedList<E>
• Iterator.remove() es O(1). 
• ListIterator.add(E element) es O(1). 

ArrayList Big O notation

• get(int index) es O(1). Es una de las principales características de ArrayList.
• add(E element) es  O(1) por lo general, aunque puede ser O(n) en el peor de los casos si hay que redimensionar y copiar el array.
• add(int index, E element) es O(n).
• remove(int index) es O(n)
• Iterator.remove() es O(n) 
• ListIterator.add(E element)es  O(n).

Como podemos ver en la comparación anterior, por lo general va a ser más recomendable el uso de ArrayList a excepción de los casos en los que necesitemos primer o último elemento.

Conclusión en el uso de Peek PeekFirst y PeekLast en LinkedList

El uso de Peek PeekFirst y PeekLast en LinkedList, tal y como hemos comentado al principio del artículo, será muy útil para obtener el primer o último elemento. Por lo que dependerá del uso que queramos hacer, por ejemplo si necesitamos hacer accesos intermedios será mucho mejor hacer uso de un ArrayList, ya que no penalizará tanto la obtención del elemento.