Iterator in Java

In Java, an Iterator is one of the Java cursors. Java Iterator is an interface that is practiced in order to iterate over a collection of Java object components entirety one by one. It is free to use in the Java programming language since the Java 1.2 Collection framework. It belongs to java.util package.

Though Java Iterator was introduced in Java 1.2, however, it is still not the oldest tool available to traverse through the elements of the Collection object. The oldest Iterator in the Java programming language is the Enumerator predated Iterator. Java Iterator interface succeeds the enumerator iterator that was practiced in the beginning to traverse over some accessible collections like the ArrayLists.

The Java Iterator is also known as the universal cursor of Java as it is appropriate for all the classes of the Collection framework. The Java Iterator also helps in the operations like READ and REMOVE. When we compare the Java Iterator interface with the enumeration iterator interface, we can say that the names of the methods available in Java Iterator are more precise and straightforward to use.

Advantages of Java Iterator

Iterator in Java became very prevalent due to its numerous advantages. The advantages of Java Iterator are given as follows –

The user can apply these iterators to any of the classes of the Collection framework.
In Java Iterator, we can use both of the read and remove operations.
If a user is working with a for loop, they cannot modernize(add/remove) the Collection, whereas, if they use the Java Iterator, they can simply update the Collection.
The Java Iterator is considered the Universal Cursor for the Collection API.
The method names in the Java Iterator are very easy and are very simple to use.

Disadvantages of Java Iterator

Despite the numerous advantages, the Java Iterator has various disadvantages also. The disadvantages of the Java Iterator are given below –

The Java Iterator only preserves the iteration in the forward direction. In simple words, the Java Iterator is a uni-directional Iterator.
The replacement and extension of a new component are not approved by the Java Iterator.
In CRUD Operations, the Java Iterator does not hold the various operations like CREATE and UPDATE.
In comparison with the Spliterator, Java Iterator does not support traversing elements in the parallel pattern which implies that Java Iterator supports only Sequential iteration.
In comparison with the Spliterator, Java Iterator does not support more reliable execution to traverse the bulk volume of data.

How to use Java Iterator?

When a user needs to use the Java Iterator, then it’s compulsory for them to make an instance of the Iterator interface from the collection of objects they desire to traverse over. After that, the received Iterator maintains the trail of the components in the underlying collection to make sure that the user will traverse over each of the elements of the collection of objects.

If the user modifies the underlying collection while traversing over an Iterator leading to that collection, then the Iterator will typically acknowledge it and will throw an exception in the next time when the user will attempt to get the next component from the Iterator.

Java Iterator Methods

The following figure perfectly displays the class diagram of the Java Iterator interface. It contains a total of four methods that are:

hasNext()
next()
remove()
forEachRemaining()

The forEachRemaining() method was added in the Java 8. Let’s discuss each method in detail.

boolean hasNext(): The method does not accept any parameter. It returns true if there are more elements left in the iteration. If there are no more elements left, then it will return false.
If there are no more elements left in the iteration, then there is no need to call the next() method. In simple words, we can say that the method is used to determine whether the next() method is to be called or not.
E next(): It is similar to hasNext() method. It also does not accept any parameter. It returns E, i.e., the next element in the traversal. If the iteration or collection of objects has no more elements left to iterate, then it throws the NoSuchElementException.
default void remove(): This method also does not require any parameters. There is no return type of this method. The main function of this method is to remove the last element returned by the iterator traversing through the underlying collection. The remove () method can be requested hardly once per the next () method call. If the iterator does not support the remove operation, then it throws the UnSupportedOperationException. It also throws the IllegalStateException if the next method is not yet called.
default void forEachRemaining(Consumer action): It is the only method of Java Iterator that takes a parameter. It accepts action as a parameter. Action is nothing but that is to be performed. There is no return type of the method. This method performs the particularized operation on all of the left components of the collection until all the components are consumed or the action throws an exception. Exceptions thrown by action are delivered to the caller. If the action is null, then it throws a NullPointerException.

Example of Java Iterator

Now it’s time to execute a Java program to illustrate the advantage of the Java Iterator interface. The below code produces an ArrayList of city names. Then we initialize an iterator applying the iterator () method of the ArrayList. After that, the list is traversed to represent each element.

JavaIteratorExample.java

  import java.io.*;  import java.util.*;      public class JavaIteratorExample {      public static void main(String[] args)      {          ArrayList cityNames = new ArrayList();              cityNames.add(“Delhi”);          cityNames.add(“Mumbai”);          cityNames.add(“Kolkata”);          cityNames.add(“Chandigarh”);          cityNames.add(“Noida”);              // Iterator to iterate the cityNames          Iterator iterator = cityNames.iterator();              System.out.println(“CityNames elements : “);              while (iterator.hasNext())              System.out.print(iterator.next() + ” “);              System.out.println();      }  }  

Output:

CityNames elements:   Delhi Mumbai Kolkata Chandigarh Noida

Points to Remember

The Java Iterator is an interface added in the Java Programming language in the Java 1.2 Collection framework. It belongs to java.util package.
It is one of the Java Cursors that are practiced to traverse the objects of the collection framework.
The Java Iterator is used to iterate the components of the collection object one by one.
The Java Iterator is also known as the Universal cursor of Java as it is appropriate for all the classes of the Collection framework.
The Java Iterator also supports the operations like READ and REMOVE.
The methods names of the Iterator class are very simple and easy to use compared to the method names of Enumeration Iterator.

Next TopicCollections in Java

Java Iterator Interface