LinkedList in Java

LinkedList in java is a resizable array like ArrayList. There is no size limit in LinkedList. When you add new elements or items in the LinkedList, the size or capacity of LinkedList will grow like Java ArrayList. You can do many things like add new elements, remove elements, change elements, sort the elements etc. like ArrayList. Both ArrayList and LinkedList implements List interface. Thus, possibly all the methods you can use in the ArrayList can also be used in LinkedList.

Syntax

//non-generic or row types
LinkedList list = new LinkedList();

//Generic approach: (with wrapper types)
LinkedList<T> list = new LinkedList(); ////T stands for type but wrapper. Primitive is not supported.

//such as 
LinkedList<String> list = new LinkedList();

Example of Creating, Adding and Accessing Elements of LinkedList

In this very first example, we will see how to create generic LinkedList, adding new elements to the LinkedList and accessing elements using index number.

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        LinkedList<String> planets = new LinkedList<>();
        planets.add("Earth");
        planets.add("Jupiter");
        planets.add("Saturn");
        planets.add("Mars");

        //accessing first element using get(index) method
        System.out.println("First Element: "+planets.get(0)); //returns the first element
        //access the fits el using getFirst method
        System.out.println("First Element (using getFirst): "+planets.getFirst());
        System.out.println("Second Element: "+planets.get(1));
        System.out.println("Last Element: "+planets.get(planets.size() - 1));
        //returns last el using getLast method
        System.out.println("Last Element (using  getLast): "+planets.getLast());
    }
}

/**
 * Output:
 * First Element: Earth
 * First Element (using getFirst): Earth
 * Second Element: Jupiter
 * Last Element: Mars
 * Last Element (using  getLast): Mars
 */

Iterating LinkedList

we can simply iterate or loop through LinkedList elements using for loop, enhanced for loop or built in Iterator interface.

Using For Loop

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        LinkedList<String> planets = new LinkedList<>();
        planets.add("Earth");
        planets.add("Jupiter");
        planets.add("Saturn");
        planets.add("Mars");

        //iterating LinkedList elements using for loop
        for (int i = 0; i < planets.size(); i++) {
            System.out.println(planets.get(i));
        }
    }
}

/**
 * Output:
 * Earth
 * Jupiter
 * Saturn
 * Mars
 */

Using Enhanced For Loop

//iterating LinkedList elements using enhanced for loop
    for (String planet : planets) {
        System.out.println(planet);
    }

/**
 * Output:
 * Earth
 * Jupiter
 * Saturn
 * Mars
 */

Using Iterator Interface

import java.util.Iterator;

//iterate planets elements using Iterator interface
    Iterator<String> list = planets.iterator();
    while (list.hasNext()){
        System.out.println(list.next());
    }

Note: Which approach should I use to iterate LinkedList? Usually it depends on requirements and performances. Specially, IDE suggests to use enhanced for loop to iterate Collection type elements. But, you can choose whatever prefer most.

LinkedList Built in Methods

Methods for LinkedList:

Key Things to Note About Java LinkedList

• LinkedList is one kind of Collection Type in Java
• It is resizable Array and the implementation of the List interface
• You can create LinkedList generic or non-generic order.
• There is no size limit of LinkedList in java
• The capacity or size of LinkedList can grow when you add new elements in it
• The members of LinkedList are ordered, index based, mutable (new elements can be added or removed as well)
• LinkedList supports duplicate elements
• Allowed only wrapper types and only one type (Integer or String not both)
• LinkedList size can be modified unlike Java Array type
• There is no need to specify the size of LinkedList