Java Iterator

An Iterator in Java is an interface used to traverse elements in a Collection sequentially. It provides methods like hasNext(), next(), and remove() to loop through collections and perform manipulation. An Iterator is a part of the Java Collection Framework, and we can use it with collections like ArrayList, LinkedList, and other classes that implement the Collection interface.

Example: Here, we will use an Iteratorto traverse and print each element in an ArrayList.

import java.util.ArrayList;
import java.util.Iterator;

public class Geeks {
    public static void main(String[] args) {
      
        // Create an ArrayList 
        // and add some elements
        ArrayList<String> al = new ArrayList<>();
        al.add("A");
        al.add("B");
        al.add("C");

        // Obtain an iterator for the ArrayList
        Iterator<String> it = al.iterator();

        // Iterate through the elements 
        // and print each one
        while (it.hasNext()) {
          
            // Get the next element
            String n = it.next(); 
            System.out.println(n);      
        }
    }
}

A
B
C

A Java Cursor is an Iterator, that is used to iterate or traverse or retrieve a Collection or Stream object’s elements one by one.

Types of Cursors in Java

There are 3 cursors in Java as mentioned below:

• Iterator
• Enumeration
• ListIterator

Note: SplitIterator can also be considered as a cursor as it is a type of Iterator only.

Important Point: Iterator is a concrete implementation of a cursor. The cursor refers to the general concept of traversing a collection but the iterator is one specific implementation of that concept in Java.

Iterators in Java are used in the Collection framework to retrieve elements one by one. It is a universal iterator as we can apply it to any Collection object. Using an Iterator, we can perform read and remove operations on the elements.

Syntax

To use an iterator, we have to first create it from any collection object that implements the Collection interface.

Iterator<E> itr = collection.iterator();

Here, collection is an object of any class implementing the Collection interface.

Methods of Iterator Interface

The iterator interface defines three methods as listed below:

1. hasNext(): Returns true if the iteration has more elements.

public boolean hasNext();

2. next(): Returns the next element in the iteration. It throws NoSuchElementException if no more element is present.

public Object next();

3. remove(): Removes the next element in the iteration. This method can be called only once per call to next().

public void remove();

Note: remove() method can throw two exceptions namely as follows:

• UnsupportedOperationException: If the remove operation is not supported by this iterator
• IllegalStateException: If the next method has not yet been called, or the remove method has already been called after the last call to the next method.

Internal Working

In this section, we will try to understand how Java Iterator and its methods work internally. Let us take the following LinkedList object to understand this functionality.

List<String> cities = new LinkedList<>();
cities.add("G-1");
cities.add("G-2");
cities.add("G-3");
.
.
.
cities.add("G-n");

Step 1: Now, let us create an Iterator object on the List object as shown below:

Iterator<String> citiesIterator = cities.iterator();

The "citiesIteartor" iterator will look like below:

Here Iterator’s Cursor is pointing before the first element of the List.

Step 2: Now, we will run the following code snippet.

citiesIterator.hasNext();
citiesIterator.next();

When we run the above code snippet, Iterator’s Cursor points to the first element in the list as shown in the above diagram.

Step 3: Now, we will run the following code snippet.

citiesIterator.hasNext();
citiesIterator.next();

When we run the above code snippet, Iterator’s Cursor points to the second element in the list as shown in the above diagram.

Step 4: Do this process to reach the Iterator’s Cursor to the end element of the List.

Step 5: After reading the final element, if we run the below code snippet, it returns a “false” value.

citiesIterator.hasNext();

As Iterator’s Cursor points to the after the final element of the List, hasNext() method returns a false value.

Note: After observing all these diagrams, we can say that Java Iterator supports only Forward Direction Iteration as shown in the below diagram. So it is also known as Uni-Directional Cursor.

Example: Here, we will use an Iteratorto traverse and remove odd elements from an ArrayList.

import java.util.ArrayList;
import java.util.Iterator;

public class Geeks {

    public static void main(String[] args) {
        
        // Creating an ArrayList 
        // object of Integer type
        ArrayList<Integer> al = new ArrayList<>();

        // Adding elements to the ArrayList
        for (int i = 0; i < 10; i++) {
            al.add(i);
        }

        // Printing the original list
        System.out.println("Original List: " + al);

        // Creating an Iterator for the ArrayList
        Iterator<Integer> itr = al.iterator();

        // Iterating through the list 
        // and removing odd elements
        while (itr.hasNext()) {
          
            // Getting the next element
            int i = itr.next();  
            
            System.out.print(i + " ");  

            // Removing odd elements
            if (i % 2 != 0) {
                itr.remove();
            }
        }

        // Moving to the next line
        System.out.println();

        // Printing the modified list 
        // after removal of odd elements
        System.out.println("Modified List: " + al);
    }
}

Original List: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0 1 2 3 4 5 6 7 8 9 
Modified List: [0, 2, 4, 6, 8]

Explanation: In the above example, we create an ArrayList of integers theniterates through it using an Iterator, and removes all odd numbers. It prints the list before and after removing the odd elements and prints the modified list with only even numbers.

Types of Iterators

1. ListIterator

The ListIterator extends Iterator and allows both forward and backward traversal. It also supports element modification during iteration.

ListIterator<E> listItr = list.listIterator();

2. Enumeration

An enumeration is an older interface from Java 1.0 used for iterating over collections. It only supports forward iteration and does not allow element removal.

Enumeration<E> e = collection.elements();

Example: The below example demonstrates different iterator types that are Enumeration, Iterator, and ListIterator.

// Demonstrating iterator references in Java
import java.util.Enumeration;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Vector;

public class Geeks {

    public static void main(String[] args) {
      
        // Create a Vector object
        Vector v = new Vector();

        // Initialize iterators
        Enumeration e = v.elements();
        Iterator itr = v.iterator();
        ListIterator ltr = v.listIterator();

        // Print class names of iterators
        System.out.println(e.getClass().getName());
        System.out.println(itr.getClass().getName());
        System.out.println(ltr.getClass().getName());
    }
}

java.util.Vector$1
java.util.Vector$Itr
java.util.Vector$ListItr

Explanation: The above example shows the use of different iterators for a Vector object in Java. It prints the class names of each iterator and shows how they are implemented internally.

Advantages of Iterator

• The Iterator is a simple and easy-to-use interface that allows us to traverse a collection without exposing its underlying implementation.
• The Iterator is an efficient way to iterate over a collection, especially when we have a large amount of data.
• The Iterator provides a safe way to remove elements from a collection during iteration without causing any concurrent modification exceptions.
• The Iterator interface is implemented by all the collection classes in Java, so we can use the same code to iterate over different types of collections.

Disadvantages of Iterator

• The Iterator is a unidirectional interface, meaning that we can only move forward through a collection. We cannot move backward or jump to a specific element.
• The Iterator is not thread-safe, so we cannot use it to iterate over a collection in a multi-threaded environment without proper synchronization.
• The Iterator does not provide any mechanism to modify elements while iterating over a collection, apart from removing elements. If we need to modify elements, we have to use other interfaces like ListIterator or a simple for loop.

kartik

Follow

Improve

Article Tags :

• Misc
• Java
• Java-Collections
• Java-Iterator

Practice Tags :

• Java
• Java-Collections
• Misc