Enumeration vs Iterator vs ListIterator in Java
Last Updated :
02 Sep, 2020
Enumeration is an interface. It is used in the collection framework in java to retrieve the elements one by one. Enumeration is a legacy interface that is applicable only for legacy classes like Vector, HashTable, Stack, etc. It provides a single direction iteration. By using enumeration, we can perform only read operation, and we cannot perform remove operation.
Enumeration object can be created by calling elements() method present in the Vector class.
// Here "v" is a vector object. enum is of
// type Enumeration interface and refers to "v"
Enumeration enum = v.elements();
An iterator is a universal cursor that can be applied to any collection object. It provides a single direction iteration. By using an iterator, we can perform both read and remove operation, but we cannot perform replace operation. Iterator must be used whenever we want to enumerate elements in all collection framework implemented interfaces like Set, List, Queue, DeQue, and also implemented classes of Map interface.
Iterator object can be created by calling iterator() method present in the Collection interface
// Here "c" is any collection object. itr is of
// type Iterator interface and refers to "c"
Iterator itr = c.iterator();
ListIterator is the most powerful cursor among all the three cursors. ListIterator is only applicable for list implemented classes like ArrayList, LinkedList, Stack, etc. ListIterator traverses both in the forward and backward direction. By using ListIteartor, we can perform read, remove, and replace operation. The ListIterator must be used when we want to enumerate elements of the list.
ListIterator object can be created by calling listIterator() method present in the list interface.
// Here "l" is any list object. ltr is of
// type ListIterator interface and refers to "l"
ListIterator ltr = l.listIterator();
Java
// A Java program to demonstrates the
// difference between Enumeration,
// Iterator, and ListIterator
import java.io.*;
import java.util.*;
class GFG {
public static void main(String args[])
{
// Creating a vector object
Vector<Integer> v = new Vector<Integer>();
// Adding elements to the vector object
v.add(10);
v.add(20);
v.add(30);
v.add(40);
v.add(50);
System.out.println("Enumeration: ");
// Creating an Enumeration object
Enumeration e = v.elements();
// Checking the next element availability
while (e.hasMoreElements()) {
// Moving cursor to the next element
int i = (Integer)e.nextElement();
// Printing the element
System.out.print(i + " ");
}
System.out.println();
System.out.println();
System.out.println("Iterator: ");
// Creating Iterator object
Iterator<Integer> itr = v.iterator();
// Checking the next element availability
while (itr.hasNext()) {
// Moving cursor to the next element
int i = (Integer)itr.next();
// Checking if i == 10 then
// remove the element
if (i == 10)
itr.remove();
}
System.out.println(v);
System.out.println();
System.out.println("ListIterator: ");
// Creating ListIterator object
ListIterator<Integer> ltr = v.listIterator();
// Checking the next element availability
while (ltr.hasNext()) {
// Moving cursor to the next element
int i = (Integer)ltr.next();
// Performing add, remove, and
// replace operation
if (i == 20)
ltr.remove();
else if (i == 30)
ltr.add(60);
else if (i == 40)
ltr.set(100);
}
System.out.println(v);
}
}
OutputEnumeration:
10 20 30 40 50
Iterator:
[20, 30, 40, 50]
ListIterator:
[30, 60, 100, 50]
Table showing the Difference between Enumeration, Iterator, and ListIterator
| Property | Enumeration | Iterator | ListIterator |
| 1. Where we can apply? | It can be applied only to the legacy classes. | It can be applied to any collection interface. | It can be applied to the only list interface. |
| 2. Is it a legacy? | Yes (introduced in 1.0 V). | No (introduced in 1.2 V). | No (introduced in 1.2 V). |
| 3. Allowed Movement | Single direction, i.e we can traverse elements present in the collection only in the forward direction. | Single direction, i.e we can traverse elements present in the collection only in the forward direction. | Bidirectional, i.e we can traverse elements present in the collection both in forward and backward directions. |
| 4. Allowed Operation | We can only perform the read operation. | We can perform read and remove operation. | We can perform read, remove, add, and replace operations. |
| 5. How can we get it? | By calling elements() method present in the vector class. | By calling iterator() method present in any collection interface. | By calling listIterator() method present in the list interface. |
Similar Reads
Convert an Iterator to a List in Java Given an Iterator, the task is to convert it into List in Java. Examples: Input: Iterator = {1, 2, 3, 4, 5} Output: {1, 2, 3, 4, 5} Input: Iterator = {'G', 'e', 'e', 'k', 's'} Output: {'G', 'e', 'e', 'k', 's'} Below are the various ways to do so: Naive Approach: Get the Iterator. Create an empty lis
2 min read
Enumeration Interface In Java java.util.Enumeration interface is one of the predefined interfaces, whose object is used for retrieving the data from collections framework variable( like Stack, Vector, HashTable etc.) in a forward direction only and not in the backward direction. This interface has been superceded by an iterator.
3 min read
Iterator vs Collection in Java Iterator and Collection, both has helped and comforted the programmers at many a times. But their usage and application has a very wide difference. 1. Iterator Declaration public interface Iterator Type Parameters: E - the type of elements returned by this iteratorIterators are used in Collection fr
3 min read
Difference Between Iterator and Spliterator in Java The Java Iterator interface represents an object capable of iterating through a collection of Java objects, one object at a time. The Iterator interface is one of the oldest mechanisms in Java for iterating collections of objects (although not the oldest — Enumerator predated Iterator). Moreover, an
4 min read
Deque iterator() method in Java The iterator() method of Deque Interface returns an iterator over the elements in this deque in a proper sequence. The elements will be returned in order from first (head) to last (tail). The returned iterator is a “weakly consistent†iterator. Syntax: Iterator iterator() Parameters: This method doe
3 min read
How to use Iterator in Java? 'Iterator' is an interface which belongs to collection framework. It allows us to traverse the collection, access the data element and remove the data elements of the collection. java.util package has public interface Iterator and contains three methods: boolean hasNext(): It returns true if Iterato
3 min read