LinkedList listIterator() method - Syntax and Examples

Learn about the Java LinkedList's `listIterator(int index)` method. This tutorial provides a detailed explanation of its syntax, parameters, return value, and practical examples.

This reference explains LinkedList listIterator() method - Syntax and Examples through its syntax, examples and boundaries. Use the linked course lessons when the surrounding Java concepts are unfamiliar.

The listIterator() method in Java's LinkedList class is a powerful tool for iterating over the list elements. Specifically, `listIterator(int index)` lets you create a list iterator that starts at a specified position within the linked list. This is particularly useful when you need to iterate from a point other than the beginning of the list.

public ListIterator<E> listIterator(int index)

The method returns an instance of the ListIterator<E> interface, which allows you to traverse the list forward or backward.

This example demonstrates creating a list iterator starting at index 2 of a linked list and then using it to iterate through the remaining elements.

import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListListIteratorExample {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Date");
        list.add("Fig");

        ListIterator<String> iterator = list.listIterator(2); // Start at index 2 (Cherry)

        System.out.println("Iterating from index 2:");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

Iterating from index 2:
Cherry
Date
Fig

Explanation: We create a LinkedList containing some fruits. Then, we initialize a ListIterator starting at index 2. The loop iterates through the remaining elements (Cherry, Date, and Fig) using the `next()` method of the iterator.

This example shows how to use the list iterator to modify the LinkedList while iterating, starting from a specific index.

import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListListIteratorModifyExample {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Date");

        ListIterator<String> iterator = list.listIterator(1); // Start at index 1 (Banana)

        System.out.println("Original List: " + list);

        iterator.set("Mango");  // Replace Banana with Mango
        iterator.add("Grape");   // Insert Grape after Mango
        iterator.previous();      // Go back to the previous element (Mango)
        iterator.remove();       // Remove Mango

        System.out.println("Modified List: " + list);
    }
}

Original List: [Apple, Banana, Cherry, Date]
Modified List: [Apple, Cherry, Date]

Explanation: We start the iterator at index 1 (Banana). We use `set()` to replace "Banana" with "Mango". Then we add "Grape" after Mango. Finally, we go back to Mango and remove it.

This example demonstrates creating a list iterator starting at index 3 and then using the `previous()` method to iterate backward through the linked list.

import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListListIteratorBackwardExample {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Date");
        list.add("Fig");

        ListIterator<String> iterator = list.listIterator(3); // Start at index 3 (Date)

        System.out.println("Iterating backward from index 3:");
        while (iterator.hasPrevious()) {
            System.out.println(iterator.previous());
        }
    }
}

Iterating backward from index 3:
Date
Cherry
Banana

Explanation: The iterator is initialized at index 3 (Date). The `hasPrevious()` method checks if there are elements before the current position, and `previous()` moves the iterator back one element each time. This continues until we reach the beginning of the list.

Check the example’s types, inputs and documented behavior before copying it into an application. Some APIs require external libraries, files or platform services; consult their setup notes.

Related explanations: Java Data Types - Primitive and Non-Primitive, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide.