ListIterator in Java

ListIterator is one of the four Java cursors. It is an iterator used to traverse all types of lists, such as ArrayList, LinkedList, Vector and Stack. It was introduced in Java 1.2 and extends the Iterator interface, providing bi-directional traversal along with support for all CRUD operations.

Hierarchy of ListIterator

Key Features of ListIterator

• It works only with list-implemented classes.
• It supports bi-directional traversal (forward & backward).
• Supports Create, Read, Update, Delete (CRUD) operations.
• Introduced in Java 1.2.

Interesting Fact about ListIterator

There is no current element in ListIterator. Its cursor always lies between the previous and next elements. The previous() will return to the previous elements and the next() will return to the next element. Therefore, for a list of length n, there are n+1 possible cursors.

Syntax: Declaration

public interface ListIterator<E> extends Iterator<E>

Where E represents the generic type i.e any parameter of any type/user-defined object.

Getting a ListIterator

ListIterator<E> listIterator()

This returns the list iterator of all the elements of the list.

Example:

import java.util.*;

public class ListIteratorDemo {
  
    // Main driver method 
    public static void main(String[] args)
    {
        // Creating a list of names
        List<String> names = new LinkedList<>();
      
        names.add("Welcome");
        names.add("To");
        names.add("Gfg");

        // Getting ListIterator
        ListIterator<String> namesIterator
            = names.listIterator();

        // Traversing elements using next() method 
        while (namesIterator.hasNext()) {
            System.out.println(namesIterator.next());
        }

        // for-each loop creates Internal Iterator here.
        for (String s : names) {
            System.out.println(s);
        }
    }
}

Welcome
To
Gfg
Welcome
To
Gfg

Forward and Backward Traversal

1. Forward direction iteration

• hasNext(): This method returns true when the list has more elements to traverse while traversing in the forward direction
• next(): This method returns the next element of the list and advances the position of the cursor.
• nextIndex(): This method returns the index of the element that would be returned on calling the next() method.

2. Backward direction iteration

• hasPrevious(): This method returns true when the list has more elements to traverse while traversing in the reverse direction
• previous(): This method returns the previous element of the list and shifts the cursor one position backward.
• previousIndex(): This method returns the index of the element that would be returned on calling the previous() method.

Example

import java.util.*;

public class GFG {
  
    public static void main(String[] args)
    {
          // list of names
        List<String> names = new LinkedList<>();
        names.add("learn");
        names.add("from");
        names.add("Geeksforgeeks");

        // Getting ListIterator
        ListIterator<String> listIterator
            = names.listIterator();

        // Traversing elements
        System.out.println("Forward Direction Iteration:");
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }

        // Traversing elements, the iterator is at the end at this point
        System.out.println("Backward Direction Iteration:");
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }
    }
}

Forward Direction Iteration:
learn
from
Geeksforgeeks
Backward Direction Iteration:
Geeksforgeeks
from
learn

Difference between Iterator and ListIterator

Similarities:

• They both are introduced in java 1.2.
• They both are used for iteration lists.
• They both support forward direction traversal.
• They both supports READ and DELETE operations.

Methods of ListIterator

ListIterator in Java

Visit Course