Iterators in Java are used to retrieve the elements one by one in the collection framework. It is also called cursors of Java. Let’s understand this concept by real-time example.

Suppose that there are 20 apples in a box. If I ask you how will you eat all these 20 apples? one by one or all apples at once time. I hope that your answer will be definitely one by one. That is, you will eat the first apple. After that, you will eat the second apple and so on.

Similarly, you assume that box is a collection, and apples in the box are elements of the collection. So if we want to get these elements one by one, we will require some iterators or cursors to retrieve elements one by one in Java. Therefore, we learn iterators or cursors concepts in Java.

Enumeration is the first iterator and introduced in Java 1.0 version. It is located in java.util package. It is a legacy interface that is implemented to get elements one by one from the legacy collection classes such as Vector and Properties.

Legacy classes are those classes which are coming from the first version of Java. Early versions of Java do not include collections framework. Instead, it defined several classes and one interface for storing objects.

When collections came in the Java 1.2 version, several of original classes were re-engineered to support the collection interfaces.

Thus, they are fully compatible with the framework. These old classes are known as legacy classes. The legacy classes defined by java.util are Vector, Hashtable, Properties, Stack, and Dictionary. There is one legacy interface called Enumeration.


Enumeration is read-only. You can just read data from the vector. You cannot remove from the vector using Enumeration.

Since enumeration is an interface so we cannot create an object of enumeration directly. We can create object of enumeration by using elements() method of the Vector class.
Syntax:

public Enumeration elements() // Return type is Enumeration.
For example:
    Enumeration e = v.elements(); // Here, v is a vector class object.

Now you will think that how can create object of Enumeration Interface?

Actually, we cannot create the object of Interface directly or indirectly. When we create an object of interface like this:
    Enumeration e = v.elements();

Internally, elements() method will be executed in the vector class. See below the snippet code.

class Vector 
{
 elements()
 {
  class  implements Enumeration
  {
    . . . . . . . 
    . . . . . . .
  }
    return (implemented class object);
 } 
}

You can see the above code that within elements() method, there is a class that implements enumeration and the implemented class object is gone to return. We can print corresponding internally implemented class name on the console by below snippet code.

Enumeration e = v.elements();
System.out.println(e.getClass().getName()); // Output: vector$1

vector$1 ➨ Inside vector, $ is the inner class name and 1 is the convention which is applicable for anonymous class.

Thus, when we are creating enumeration object, internally, we are creating enumeration implemented class object. Similarly, the same thing happens in the case of Iterator and ListIterator. Let’s see the code structure.

Program source code 1:

The Enumeration interface defines the following two methods. They are as follows:

1. public boolean hasMoreElements(): When this method is implemented, hasMoreElements() will return true If there are still more elements to extract and false if all the elements have been enumerated. 

2. public Object nextElement(): The nextElement() method returns next element in the enumeration. It will throw NoSuchElementException when the enumeration is complete. 


Let’s take an example program based on concepts of these methods to understand better.
Program source code 2:

Limitation of Enumeration

1. Enumeration concept is applicable for only legacy class. Hence, it is not a universal cursor.
2. We can get only read operation by using the enumeration. We cannot perform remove operation.
3. We can iterate using enumeration only in the forward direction.
To overcome these limitations, We should go for the next level Iterator concept.

Iterator in Java

Iterator object can be created by calling iterator() method which is present in the Collection interface.

public Iterator iterator() // Return type is Iterator.
For example:
   Iterator itr = c.iterator(); // c is any collection object.
   Iterator itr = c.iterator(); // Generic type.

Methods of Iterator in Java

The Iterator interface provides three methods in Java. They are as follow:

1. public boolean hasNext(): This method will return true if the iteration has more elements in the forward direction. It will give false if all the elements have been iterated.

2. public Object next(): The next() method return next element in the collection. It will throw NoSuchElementException when the iteration is complete.

3. public void remove(): The remove() method removes the last or the most recent retrieved element by the iterator. It must be called after calling next() method otherwise it will throw IllegalStateException. 

Let’ see a simple example program on these methods in an easy way and step by step.

Program source code 4:

package iteratorsTest; 
import java.util.ArrayList; 
import java.util.Iterator; 
public class IteratorTest 
{ 
 public static void main(String[] args)  
 { 
// Create the object of ArrayList of type Integer. 
   ArrayList al = new ArrayList(); 
 for(int i = 0; i  itr = al.iterator(); 
// Checking the next element availability using reference variable itr. 
   while(itr.hasNext())
   { 
// Moving cursor to next element using reference variable itr. 
    Integer i = itr.next(); // Here, Type casting does not require due to using of generic with Iterator. 
    System.out.println(i); 
// Removing odd elements. 
   if(i % 2! = 0) 
     itr.remove(); 
   } 
  System.out.println(al); 
 } 
}

Look at the below picture to understand the concept of above program.

Output: 
       [0, 1, 2, 3, 4, 5, 6, 7, 8] 
       0 1 2 3 4 5 6 7 8 [0, 2, 4, 6, 8]

Main difference between Enumeration and iterator with respect to functionality

By using an enumeration, we can perform only read access but using an iterator, we can perform both read and remove operation.

Advantage of Iterator in Java

How to create ListIterator object in Java?

public ListIterator listIterator()  // return type is ListIterator.
For example:
  ListIterator litr = l.listIterator(); // l is any list object.

package iteratorsTest; 
import java.util.ArrayList; 
import java.util.ListIterator; 
public class ListIteratorTest 
{ 
 public static void main(String[] args) 
 { 
   ArrayList al = new ArrayList(); 
   al.add("Apple"); 
   al.add("Orange"); 
   al.add("Banana"); 
   al.add("Guava"); 
   al.add("Pineapple"); 
  System.out.println(al); 

// Create the object of ListIterator using listIterator() method. 
   ListIterator litr = al.listIterator(); 
   while(litr.hasNext())
   { 
    Object o = litr.next(); 
    String str = (String)o; // Type casting. 
   if(str.equals("Orange"))
   { 
     litr.remove(); // It will remove orange from the list. 
     System.out.println(al); 
   } 
  else if(str.equals("Guava"))
  { 
     litr.add("Grapes"); // Adding Grapes after guava. 
    System.out.println(al); 
  } 
  else if(str.equals("Pineapple"))
  { 
    litr.set("Pears"); // Replacing Pineapple element. 
    System.out.println(al); 
   } 
  } 
 } 
}

Output: 
      [Apple, Orange, Banana, Guava, Pineapple] 
      [Apple, Banana, Guava, Pineapple] 
      [Apple, Banana, Guava, Grapes, Pineapple] 
      [Apple, Banana, Guava, Grapes, Pears]