Java - LinkedList

LinkedList in Java

Java LinkedList is one of the most important and frequently used data structures in the Java Collections Framework. It is widely searched by Java beginners, intermediate learners, and advanced developers because understanding LinkedList helps improve coding, problem-solving, logic-building, and DSA performance. This detailed document covers the definition of LinkedList, its internal working, features, advantages, disadvantages, performance analysis, commonly asked interview questions, and fully explained programs with outputs. Every section is optimized with high-reach keywords such as "Java LinkedList tutorial", "Java Collections Framework", "Linked List methods in Java", "Java data structures", "Difference between ArrayList and LinkedList", and more to increase visibility and impressions.

What is LinkedList in Java?

LinkedList in Java is a part of the java.util package and represents a linear data structure where elements are stored in nodes. Each node contains two parts – the data itself and the reference (or pointer) to the next node and previous node. This is why LinkedList is called a doubly linked list implementation in Java. Unlike ArrayList, LinkedList does not store data in a continuous memory location. This gives it flexibility in adding and removing elements without shifting large portions of data. LinkedList is ideal for real-time applications such as playlist management, history navigation, memory-efficient insertions, and dynamic queues and stacks. Its structure makes it very efficient for operations at the beginning and middle, but comparatively slower for random access. Because of this, LinkedList is a best choice for scenarios involving frequent insert, delete, and traversal operations.

Creating a LinkedList in Java

Creating a LinkedList in Java is extremely simple because the JDK provides a built-in class that supports generics, ensuring type safety. The LinkedList can store homogeneous objects, and the size grows dynamically. When you create a LinkedList, Java internally creates a series of nodes that are connected using references. You can create LinkedList for strings, integers, objects, or any user-defined class. The syntax remains consistent and easy. Below is a basic example that shows how to create a LinkedList using generics, how to add elements, and how to print them. This example helps beginners understand the structure and usage flow before diving into deeper LinkedList functionalities.

Example: Creating a LinkedList

import java.util.LinkedList;

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

        list.add("Java");
        list.add("Python");
        list.add("C++");
        list.add("JavaScript");

        System.out.println(list);
    }
}

[Java, Python, C++, JavaScript]

Internal Working of LinkedList in Java

LinkedList internally uses a doubly linked list architecture. Each element is stored inside a node object that contains three important parts: the data value, the pointer to the previous node, and the pointer to the next node. Because of this structure, LinkedList excels in insertion and deletion operations. When you add an element at the beginning or end, LinkedList simply creates a new node and updates references, without shifting any of the existing elements. This is the opposite of ArrayList, where shifting can be expensive. However, accessing an element by index is slower in LinkedList because it must traverse nodes from the beginning or end until it reaches the target index. This sequential traversal makes LinkedList unsuitable for applications requiring fast random access. Understanding this internal working helps developers choose the right data structure based on workload.

Adding Elements in LinkedList

Java LinkedList provides multiple methods for adding elements such as add(), addFirst(), addLast(), addAll(), and add(index, element). These methods allow you to insert elements at different positions. Adding elements in LinkedList is highly efficient for insertions at the head or middle because only node pointers are changed. Unlike array-based structures, no shifting of elements occurs. This makes LinkedList ideal for queue, deque, playlist management, and similar operations. Below is a complete example demonstrating different add operations. This example is beginner-friendly and helps understand how flexible LinkedList is compared to other List implementations.

Example: Adding Elements

import java.util.LinkedList;

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

        languages.add("Java");
        languages.add("Python");
        languages.add(1, "C#");
        languages.addFirst("Go");
        languages.addLast("Rust");

        System.out.println(languages);
    }
}

[Go, Java, C#, Python, Rust]

Accessing Elements in LinkedList

LinkedList supports multiple methods such as get(), getFirst(), getLast(), peek(), and peekFirst() for retrieving elements. Accessing elements requires traversing nodes, so the time complexity for random access is O(n). This is one of the reasons why LinkedList is not recommended for applications that require frequent element lookup. Despite this, LinkedList supports rich methods for reading elements, which makes it a valuable structure for queues, stack-like behavior, and navigational applications where elements are accessed from head or tail. Understanding how retrieval works helps developers design scalable applications and choose the correct data structure for real-time scenarios.

Example: Accessing Elements

import java.util.LinkedList;

public class LinkedListExample3 {
    public static void main(String[] args) {
        LinkedList cities = new LinkedList<>();
        cities.add("Delhi");
        cities.add("Mumbai");
        cities.add("Chennai");
        cities.add("Kolkata");

        System.out.println("First: " + cities.getFirst());
        System.out.println("Last: " + cities.getLast());
        System.out.println("At index 2: " + cities.get(2));
    }
}

First: Delhi
Last: Kolkata
At index 2: Chennai

Removing Elements from LinkedList

LinkedList provides remove(), removeFirst(), removeLast(), remove(index), and remove(Object) methods for deleting elements. Removal operations in LinkedList are extremely efficient because they simply detach nodes and adjust references without shifting elements. This gives LinkedList a big advantage in scenarios involving continuous deletion operations. However, deleting an element at a specific index requires traversal, which affects performance. Below example illustrates different removal operations with clear output.

Example: Removing Elements

import java.util.LinkedList;

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

        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Mango");
        fruits.add("Orange");

        fruits.removeFirst();
        fruits.removeLast();
        fruits.remove("Banana");

        System.out.println(fruits);
    }
}

[Mango]

Iterating through a LinkedList

Iteration is an essential operation in LinkedList for accessing elements sequentially. LinkedList supports multiple ways to iterate, such as using for loop, enhanced for loop, iterator, and listIterator. Iterators are the recommended approach when dealing with modifications during traversal. LinkedList also allows reverse iteration using ListIterator, which is extremely useful for bidirectional navigation. Iteration performance is efficient because LinkedList is designed for sequential operations. Below program demonstrates different ways to iterate through LinkedList.

Example: Iterating LinkedList

import java.util.LinkedList;
import java.util.Iterator;

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

        animals.add("Lion");
        animals.add("Tiger");
        animals.add("Elephant");

        for (String a : animals) {
            System.out.println(a);
        }
    }
}

Lion
Tiger
Elephant

Difference Between ArrayList and LinkedList

ArrayList and LinkedList are both implementations of the List interface, but their internal structures and operation efficiencies differ significantly. ArrayList uses a dynamic array, making it ideal for fast random access but less efficient for insertions and deletions. LinkedList uses a doubly linked list structure, making it excellent for frequent insert/delete operations but slow for random access. ArrayList is preferred for read-intensive operations, while LinkedList is preferred for write-intensive operations. Understanding these differences helps developers choose the correct data structure.

Performance Analysis

LinkedList has specific performance characteristics due to its node-based design. Insertions and deletions at the beginning or middle are O(1), which is very efficient. However, random access is O(n), which is slower than ArrayList. Iteration is moderately efficient. LinkedList uses more memory because each node stores two extra references. Developers must consider these trade-offs when choosing between different data structures in Java Collections.

Java LinkedList is a powerful and flexible data structure that supports fast insertions and deletions, making it extremely useful in applications requiring dynamic data modification. With its node-based architecture, it plays a crucial role in queues, deques, memory-sensitive applications, and navigational operations. Even though LinkedList is slower in random access, its strengths make it one of the most essential structures in the Java Collections Framework. This document provides complete coverage of LinkedList operations, internal working, examples, outputs, advantages, and performance analysis to help learners master this topic thoroughly.