Java LinkedList Class

A linked list is basically a data structure that consists of a sequence of nodes, where each node contains a data element and a reference to the next node in the sequence. The first node in the list is called the head node, and the last node is called the tail node.

To create a linked list in Java, we use the LinkedList class, which was introduced in the Java 1.2 version and is available in the java.util package.

LinkedList is a doubly-linked list implementation of the List and Deque interfaces and provides a number of methods for adding, removing, and traversing the list.

👉 Important features of LinkedList:

✅ Best Choice: If our frequent operation is insertion or deletion in the middle of a list.

❌Worst Choice: If our frequent operation is a retrieval operation, each node contains extra memory to store the previous and next node addresses.

👉 LinkedList Class Hierarchy

As we can see from the complete LinkedList class hierarchy above, the LinkedList class extends the AbstractSequentialList class and implements List, Deque, Cloneable, and Serializable Interfaces.

👉 LinkedList Class Declaration

👉 Example : A sample Java program of LinkedList

  
  import java.util.LinkedList;
  class LinkedListExample {
    public static void main(String[] args){
      // Creating LinkedList
      LinkedList<String> countries = new LinkedList<>();
      // Adding elements in LinkedList
      countries.add("India");
      countries.add("Canada");
      countries.add("US");
      countries.add("England");
      // Printing LinkedList elements
      System.out.println("LinkedList Elements: " + countries);
    }
  }

👉 Java LinkedList Constructors

👉 Java LinkedList Methods

LinkedList Class Methods Examples

The Java LinkedList class provided methods are implemented in the below given examples. Let's go through the examples one by one and understand the uses for each method.

Constructor	Description
LinkedList()	Constructs an empty list.
LinkedList(Collection<? extends E> c)	Constructs a list containing the elements of the specified collection in the order they are returned by the collection's iterator.

Method	Description
boolean add(E element)	Appends the given element to the list.
boolean addAll(Collection c)	Appends the given collection of elements to the list.
void add(int index, E element)	Inserts the given element at the specified index.
boolean addAll(int index, Collection c)	Inserts the given collection of elements at the specified index.
void addFirst(E element)	Inserts the given element at the beggining of the list.
void addLast(E element)	Inserts the given element at the end of the list.
boolean offer(E element)	Inserts the given element at the end of the list.
boolean offerFirst(E element)	Inserts the given element at the beggining of the list.
boolean offerLast(E element)	Inserts the given element at the end of the list.
void push(E element)	Inserts the given element at the beggining of the list.
E get(int index)	Returns an element at a specified index from the list.
E getFirst()	Returns the first element from the list.
E getLast()	Returns the last element from the list.
E element()	Returns the first element from the list.
E peek()	Returns the first element from the list.
E peekFirst()	Returns the first element from the invoking LinkedList, and returns null if a list is empty.
E peekLast()	Returns the last element from the invoking LinkedList, and returns null if a list is empty.
int indexOf(E element)	Returns the index value of the first element to occur in the list.
int lastIndexOf(E element)	Returns the index value of the given element's last appearance in the list.
E set(int index, E newElement)	Replace the element at the specified index with a new element in the invoking list.
E remove()	Removes the first element from the invoking list.
E remove(int index)	Removes the element at the specified index in the invoking list.
boolean remove(Object element)	Removes the first occurrence of the given element from the invoking list.
boolean removeAll(Collection c)	Removes the given collection of elements from the invoking LinkedList.
E removeFirst()	Removes the first element from the invoking list.
E removeLast()	Removes the first element from the invoking list.
E removeFirstOccurrence(Object element)	Removes the first occurrence of the given element from the invoking LinkedList.
E removeLastOccurrence(Object element)	Removes the last occurrence of the given element from the invoking LinkedList.
E poll()	Removes the first element from the LinkedList, and returns null if the list is empty.
E pollFirst()	Removes the first element from the LinkedList, and returns null if the list is empty.
E pollLast()	Removes the last element from the LinkedList, and returns null if the list is empty.
E pop()	Removes the first element from the LinkedList.
void clear()	Removes all the elements from the LinkedList.
int size()	Returns the total number of elements in the invoking LinkedList.
boolean isEmpty()	Returns true if the list is empty; otherwise, it returns false.
boolean contains(Object element)	Returns true if the list contains the given element; otherwise, it returns false.
void sort(Comparator c)	Sorts all the elements of the invoking list based on the given comparator.
List[] subList(int startIndex, int endIndex)	Returns a list of elements starting from startIndex to endIndex-1.
Object clone()	Returns a shallow copy of a LinkedList.
Object[] toArray()	Returns an array of object instances that contains all the elements from invoking LinkedList.
Spliterator spliterator()	Creates spliterator over the elements in a list.
void trimToSize()	Used to trim a LinkedList instance to the number of elements it contains.

            
  import java.util.Arrays;
  import java.util.LinkedList;
  public class AddElementsInLinkedList {
    public static void main(String[] args) {
      // Creating LinkedList
      LinkedList<Integer> list = new LinkedList<>();
      list.add(100);
      list.add(200);
      list.add(500);
      System.out.println("LinkedList Elements: " + list);
      
      // Add element at the beginning
      list.addFirst(50);
      System.out.println("After list.addFirst(50): " + list);
      
      // Add element at the last
      list.addLast(550);
      System.out.println("After list.addLast(550): " + list);
      
      // Add element at specified position
      list.add(2, 300);
      System.out.println("After list.add(2, 300): " + list);
      
      // Add element at the beginning
      list.push(700);
      System.out.println("list.push(700): " + list);
      
      // Creating another LinkedList
      LinkedList<Integer> childList = new LinkedList<>();
      childList.add(600);
      childList.add(700);
      
      // Add another list at the end of this list
      list.addAll(childList);
      System.out.println("After list.addAll(childList): " + list);
      
      // Add another list at the specified position
      list.addAll(3, childList);
      System.out.println("After list.addAll(3, childList): " + list);
      
      // Adding the elements through array
      list.addAll(Arrays.asList(1000, 2000, 3000));
      System.out.println("After adding array: " + list);
      
      // LinkedList Declaration, Instantiation and Initialization in a single statement
      LinkedList<Character> linkedList = new LinkedList<>(Arrays.asList('A', 'B', 'C', 'D', 'E'));
      
      // Printing list values
      System.out.println("Elements: " + linkedList);
    }
  }

LinkedList Elements: [100, 200, 500]
After list.addFirst(50): [50, 100, 200, 500]
After list.addLast(550): [50, 100, 200, 500, 550]
After list.add(2, 300): [50, 100, 300, 200, 500, 550]
list.push(700): [700, 50, 100, 300, 200, 500, 550]
After list.addAll(childList): [700, 50, 100, 300, 200, 500, 550, 600, 700]
After list.addAll(3, childList): [700, 50, 100, 600, 700, 300, 200, 500, 550, 600, 700]
After adding array: [700, 50, 100, 600, 700, 300, 200, 500, 550, 600, 700, 1000, 2000, 3000]
Elements: [A, B, C, D, E]

            
  import java.util.Arrays;
  import java.util.Iterator;
  import java.util.LinkedList;
  public class AccessElementsFromLinkedList {
    public static void main(String[] args) {
      // Creating LinkedList
      LinkedList<Character> list = new LinkedList<>(
          Arrays.asList('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'));
      
      System.out.println("LinkedList Elements: " + list);
      
      // Returns the element at the specified position in this list.
      System.out.println("list.get(4): " + list.get(4));
      
      // Return the subList from given specified range of position
      System.out.println("list.subList(2, 5): " + list.subList(2, 5));
      
      // Return the first element of this list
      System.out.println("list.element(): " + list.element());
      System.out.println("list.getFirst(): " + list.getFirst());
      
      // Return the list element of this list
      System.out.println("list.getLast(): " + list.getLast());
      
      // Traversing the list in the reverse order
      System.out.println("Traversing the list in the reverse order:");
      Iterator<Character> it = list.descendingIterator();
      while(it.hasNext()) {  
        System.out.print(it.next());  
      }
        
      // Traversing the list using for loop
      System.out.println("\nTraversing the list using for loop:");
      for(Character ch : list) {
        System.out.print(ch);
      }
    }
  }

LinkedList Elements: [A, B, C, D, E, F, G, H, I, J, K]
list.get(4): E
list.subList(2, 5): [C, D, E]
list.element(): A
list.getFirst(): A
list.getLast(): K
Traversing the list in the reverse order:
KJIHGFEDCBA
Traversing the list using for loop:
ABCDEFGHIJK

            
  import java.util.Arrays;
  import java.util.LinkedList;
  public class UpdateElementsInLinkedList {
    public static void main(String[] args) {
      // Creating LinkedList
      LinkedList<Character> list = new LinkedList<>(
          Arrays.asList('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'));
      
      System.out.println("LinkedList Elements: " + list);
      
      // Replaces the element at the specified position 
      list.set(3, 'Z');
      System.out.println("After list.set(3, 'X'): " + list.set(3, 'X'));
      
      System.out.println("LinkedList Elements: " + list);
    }
  }

LinkedList Elements: [A, B, C, D, E, F, G, H, I, J, K]
After list.set(3, 'X'): Z
LinkedList Elements: [A, B, C, X, E, F, G, H, I, J, K]

            
  import java.util.Arrays;
  import java.util.LinkedList;
  public class RemoveElementsFromLinkedList {
    public static void main(String[] args) {
      // Creating LinkedList
      LinkedList<Character> list = new LinkedList<>(
          Arrays.asList('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'));
      System.out.println("LinkedList Elements: " + list);
      
      // Removes the first element
      list.remove();
      System.out.println("After list.remove(): " + list);
      
      // removes and returns the first element of this list. 
      System.out.println("list.pop(): " + list.pop());
      System.out.println("After list.pop(): " + list);
      
      // Removes the element at the specified position in this list
      list.remove(2);
      System.out.println("After list.remove(2): " + list);
      
      // Removes and returns the first element from this list.
      System.out.println("list.removeFirst(): " + list.removeFirst());
      System.out.println("list.removeFirst(): " + list);
      
      // Removes and returns the last element from this list.
      System.out.println("list.removeLast(): " + list.removeLast());
      System.out.println("list.removeLast(): " + list);
      
      // Removes the first occurrence of the specified element in this list
      System.out.println("list.removeFirstOccurrence('H'): " + list.removeFirstOccurrence('H'));
      System.out.println("After list.removeFirstOccurrence('H'): " + list);
      
      // Removes the last occurrence of the specified element in this list
      System.out.println("list.removeLastOccurrence('G'): " + list.removeLastOccurrence('G'));
      System.out.println("After list.removeLastOccurrence('G'): " + list);
      
      // Creating another LinkedList
      LinkedList<Character> childList = new LinkedList<>(Arrays.asList('A', 'E', 'I', 'O', 'U'));
        
      // Removes all of this collection's elements that are also contained in the
      // specified collection
      list.removeAll(childList);
      System.out.println("After list.removeAll(childList): " + list);
    }
  }

LinkedList Elements: [A, B, C, D, E, F, G, H, I, J, K]
After list.remove(): [B, C, D, E, F, G, H, I, J, K]
list.pop(): B
After list.pop(): [C, D, E, F, G, H, I, J, K]
After list.remove(2): [C, D, F, G, H, I, J, K]
list.removeFirst(): C
list.removeFirst(): [D, F, G, H, I, J, K]
list.removeLast(): K
list.removeLast(): [D, F, G, H, I, J]
list.removeFirstOccurrence('H'): true
After list.removeFirstOccurrence('H'): [D, F, G, I, J]
list.removeLastOccurrence('G'): true
After list.removeLastOccurrence('G'): [D, F, I, J]
After list.removeAll(childList): [D, F, J]

            
  import java.util.Arrays;
  import java.util.LinkedList;
  public class LinkedListUtilityMethod {
    public static void main(String[] args) {
      // Creating LinkedList
      LinkedList<Character> list = new LinkedList<>(
          Arrays.asList('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'));
      
      System.out.println("LinkedList Elements: " + list);
      
      // Returns true if this collection contains no elements.
      System.out.println("list.isEmpty(): " + list.isEmpty());
      
      // Returns the number of elements in this list
      System.out.println("list.size(): " + list.size());
      
      // Returns the index of the first occurrence of the specified element in this list
      System.out.println("list.indexOf('D'): " + list.indexOf('D'));
      
      // Returns true if this list contains the specified element else false
      System.out.println("list.contains('D') : " + list.contains('D'));
      
      // Creating another LinkedList
      LinkedList<Character> childList = new LinkedList<>(Arrays.asList('A', 'E', 'I', 'O', 'U'));
        
      // Returns true if this collection contains all of the elements in the specified
      // collection
      System.out.println("list.containsAll(childList): " + list.containsAll(childList));
      
      // Removes all of the elements from this list.
      list.clear();
      System.out.println("After list.clear(): " + list);
    }
  }

LinkedList Elements: [A, B, C, D, E, F, G, H, I, J, K]
list.isEmpty(): false
list.size(): 11
list.indexOf('D'): 3
list.contains('D') : true
list.containsAll(childList): false
After list.clear(): []

ArrayList	LinkedList
ArrayList internally uses a dynamic array to store the elements.	LinkedList internally uses a doubly linked list to store the elements.
ArrayList implements a List interface. Therefore, this acts as a list.	LinkedList implements both the List interface and the Deque interface. Therefore, it can act as a list and a deque.
ArrayList is slow as array manipulation is slower.	LinkedList is faster than node-based as there is not much bit shifting required.
ArrayList is best for storing and accessing elements from the list.	LinkedList is best for manipulating the elements.
ArrayList allocates contiguous memory locations.	LinkedList does not allocate contiguous memory locations.
The default capacity of an ArrayList is 10.	LinkedList has no default capacity. An empty list is created when a LinkedList is initialized.

LinkedList Class in Java

👉 Important features of LinkedList:

👉 LinkedList Class Hierarchy

👉 LinkedList Class Declaration

👉 Example : A sample Java program of LinkedList

👉 Java LinkedList Constructors

👉 Java LinkedList Methods

LinkedList Class Methods Examples

LinkedList - Interview Questions and Answers

Currently No Video available