LinkedList in Java

LinkedList is a part of the Java Collection Framework and is present in the java.util package. It implements a doubly-linked list data structure where elements (called nodes) are not stored in contiguous memory. Each node contains two parts: data and a reference to the next (and previous) node.

Example: Java program to add elements to a LinkedList.

import java.util.LinkedList;

public class Geeks {

    // Main driver method
    public static void main(String[] args) {
        // Creating a LinkedList
        LinkedList<String> l = new LinkedList<String>();

        // Adding elements to the LinkedList using add() method
        l.add("One");
        l.add("Two");
        l.add("Three");
        l.add("Four");
        l.add("Five");

        System.out.println(l);
    }
}

[One, Two, Three, Four, Five]

Note: Nodes in a LinkedList cannot be accessed directly by index like arrays. To access an element, traversal must begin from the head node and continue until the desired position is reached.

Constructors of LinkedList

In order to create a LinkedList, we need to create an object of the LinkedList class. The LinkedList class consists of various constructors that allow the possible creation of the list. The following are the constructors available in this class:
 

1. LinkedList(): This constructor is used to create an empty linked list. If we wish to create an empty LinkedList with the name list, then it can be created as: 

LinkedList list = new LinkedList();  

2. LinkedList(Collection C): This constructor is used to create an ordered list that contains all the elements of a specified collection, as returned by the collection's iterator. If we wish to create a LinkedList with the name list, then, it can be created as: 

LinkedList list = new LinkedList(C);

Performing Different Operations on LinkedList

1. Adding Elements: With the help of the add() method, we can add elements to a LinkedList This method can perform multiple operations based on different parameters. They are:  

• add(Object): This method is used to add an element at the end of the LinkedList.
• add(int index, Object): This method is used to add an element at a specific index in the LinkedList.

Example: Java program to add elements to a LinkedList

import java.util.*;

public class Geeks {

    public static void main(String args[])
    {
        LinkedList<String> ll = new LinkedList<>();

        ll.add("Geeks");
        ll.add("Geeks");
        ll.add(1, "For");

        System.out.println(ll);
    }
}

[Geeks, For, Geeks]

2. Changing Elements: With the help of the set() method, we can update an element in a LinkedList. This method takes an index and the updated element which needs to be inserted at that index.

Example: Java program to change elements in a LinkedList

import java.util.*;

public class Geeks {

    public static void main(String args[])
    {
        LinkedList<String> ll = new LinkedList<>();

        ll.add("Geeks");
        ll.add("Geeks");
        ll.add(1, "Geeks");

        System.out.println("Initial LinkedList " + ll);

        ll.set(1, "For");

        System.out.println("Updated LinkedList " + ll);
    }
}

Initial LinkedList [Geeks, Geeks, Geeks]
Updated LinkedList [Geeks, For, Geeks]

3. Removing Elements: Removes the first occurrence of the specified element from the list, if it exists. They are: 

• remove(Object): This method is used to remove an object from the LinkedList. If there are multiple objects, then the first occurrence of the object is removed.
• remove(int index): This method removes the element at the specific index in the LinkedList. After removing, the list updates so the elements shift and the LinkedList reflects the change.

Example: Java program to remove elements in a LinkedList

import java.util.*;

public class Geeks {

    public static void main(String args[])
    {
        LinkedList<String> ll = new LinkedList<>();

        ll.add("Geeks");
        ll.add("Geeks");
        ll.add(1, "For");

        System.out.println("Initial LinkedList " + ll);

          // Function call
        ll.remove(1);

        System.out.println("After the Index Removal " + ll);

        ll.remove("Geeks");

        System.out.println("After the Object Removal "
                           + ll);
    }
}

Initial LinkedList [Geeks, For, Geeks]
After the Index Removal [Geeks, Geeks]
After the Object Removal [Geeks]

4. Iterating a LinkedList: There are multiple ways to iterate through LinkedList. The most famous ways are by using the basic for loop in combination with a get() method to get the element at a specific index and the advanced for-loop.

Example: Java program to iterate the elements in an LinkedList

import java.util.*; 
  
public class Geeks { 
  
    public static void main(String args[]) 
    { 
        LinkedList<String> ll 
            = new LinkedList<>(); 
  
        ll.add("Geeks"); 
        ll.add("Geeks"); 
        ll.add(1, "For"); 
  
        // Using the Get method and the for loop 
        for (int i = 0; i < ll.size(); i++) { 
  
            System.out.print(ll.get(i) + " "); 
        } 
  
        System.out.println(); 
  
        // Using the for each loop 
        for (String str : ll) 
            System.out.print(str + " "); 
    } 
} 

Geeks For Geeks 
Geeks For Geeks 

5. Linked list to Array by using toArray(): It converts the elements of the linked list into a new array.

Example:

import java.util.*;
public class Geeks {
    public static void main(String[] args)
    {
        LinkedList<Integer> list= new LinkedList<Integer>();
        list.add(123);
        list.add(12);
        list.add(11);
        list.add(1134);
        System.out.println("LinkedList: "+ list);
        Object[] a = list.toArray();
        System.out.print("After converted LinkedList to Array: ");
        for(Object element : a)
        System.out.print(element+" ");
    }
}

LinkedList: [123, 12, 11, 1134]
After converted LinkedList to Array: 123 12 11 1134 

6. size(): This method returns the total number of elements in the linked list.

Example:

import java.io.*;
import java.util.LinkedList;

public class Geeks {
    
    public static void main(String args[]) {
        
        LinkedList<String> list = new LinkedList<String>();
        list.add("Geeks for Geeks ");
        list.add("is best ");
        
        // Displaying the size of the list
        System.out.println("The size of the linked list is: " + list.size());
    }
}

The size of the linked list is: 2

Advantages

• A linked list can dynamically grow or shrink in size as needed.
• Adding or removing elements in the middle is efficient since only links need to be updated.
• Doubly linked lists allow traversal in both forward and backward directions.

Disadvantages

• Access time is slower since elements must be accessed sequentially from the head.
• Each node stores extra memory for pointers, leading to higher memory usage.

Methods for Java LinkedList

ArrayList vs LinkedList

LinkedList in Java

Visit Course