LinkedList Java Example (with video)

In this article, we will use examples in order to understand Linked lists in Java. The Java LinkedList class can be considered as an alternative to ArrayList class. It uses a doubly linked list to store the elements in a Java program. It inherits the AbstractList class and implements List and Deque interfaces.

Also, the LinkedList allows the usage of iterators, so that you can iterate the list forwards or backwards and declare the exact position of the starting node.

You can also check this tutorial in the following video:

You can see the relations between LinkedList and other classes in the following diagram:

1. How a LinkedList works?

Internally LinkedList class in Java uses objects of type Node to store the added elements. Node is implemented as a static class within the LinkedList class. Since LinkedList class is implemented as a doubly-linked list so each node stores reference to the next as well as previous nodes along with the added element.

What does a doubly-linked list mean?

It means each node stores reference to the next as well as previous nodes.

Node class code in JDK 10

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;
 
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
}

1.1 LinkedList class declaration

Let’s see the declaration for java.util.LinkedList class.

public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, Serializable

1.2 Constructors of Java LinkedList

1.3 Methods of Java LinkedList

1.4 First and Last variables

first and last variables are for holding the reference of the first and last nodes of the linked list:

first and last nodes:

/**
* Pointer to first node.
*/
transient Node<E> first;
 
/**
* Pointer to last node.
*/
transient Node<E> last;

1.5 Adding elements in LinkedList

If you call the regular add() method or addLast() method, internally linkLast() method is called. In this method a new node is created to store the added element and the variable last starts referring to this node (as this new node becomes the last node).

linkLast() method implementation in the LinkedList class

/**
     * Links e as last element.
     */
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

If you call addFirst() method internally linkFirst() method is called. In this method a new node is created to store the added element and the variable first starts referring to this node (as this new node becomes the first node). 

LinkFirst() method implementation in the LinkedList class

/**
     * Links e as first element.
     */
    private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

1.6 moving elements from Linkedlist

Just like add() method for removing an element from the LinkedList apart from regular remove() method (where index or the element is passed) there are also removeFirst() and removeLast() methods.

When remove() method is called then the reference of the nodes at the left and right of the removed nodes have to be changed so that next of the node at left starts referring to the node at the right and the prev of the node at right starts referring to the node at the left of the node to be removed.

1.7 Getting a specific node

In the case of get() method again there are getFirst() and getLast() method too. In case of get() method it has to get the node for the passed index and return the node.item.

implementation of get() method

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

2. Example of a Java LinkedList

LinkedListExample.java

Let’s explain the above code. First, we create a linked list of strings and we add items in it. Then, we create a list iterator that will iterate the elements in the list, starting from the beginning. After that, we insert again two elements but in the beginning and in the end of the list, respectively.

As you can see we have used some already known methods from the List class. For example, we use contains method to examine whether a specific element is included in the list, then we use the indexOf method so as to find the position of a specific item, finally, we use the size method so as to retrieve the size of the list. Then, we use again the iterator of the list but at this time, we define the exact position of the starting node of the iteration. In particular, we start from the end of the list, so as to iterate the list in reverse order. Then, we delete a specified element in the list and after that, we delete the first and the last item in the list. Finally, we iterate once again the list so as to depict the final version of the list.

If we run the above code, we will have the following results:

Output:

3. More articles

• ArrayList Java Example – How to use arraylist
• Java List Example
• Java Array – java.util.Arrays Example
• Java Queue Example
• Java Stack Example

4. Download the source code

This was an example of how to use the class LinkedList.

Last updated on Apr. 27th, 2021

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.