Difference Between Iterator And ListIterator In Java

Iterator and ListIterator are two interfaces in Java collection framework which are used to traverse the collections. Although ListIterator extends Iterator, there are some differences in the way they traverse the collections.

1) Using Iterator, you can traverse List, Set and Queue type of objects. But using ListIterator, you can traverse only List objects. In Set and Queue types, there is no method to get the ListIterator object. But, In List types, there is a method called listIterator() which returns ListIterator object.

class IteratorAndListIterator
{
    public static void main(String[] args)
    {
        List list = new ArrayList();

        list.add("ONE");

        list.add("TWO");

        list.add("THREE");

        //Traversing list elements using Iterator
        Iterator iterator1 = list.iterator();

        while (iterator1.hasNext())
        {
            System.out.println(iterator1.next());
        }

        Queue queue = new PriorityQueue(list);

        //Traversing queue elements using Iterator
        Iterator iterator2 = queue.iterator();

        while (iterator2.hasNext())
        {
            System.out.println(iterator2.next());
        }

        Set set = new HashSet(list);

        //Traversing set elements using Iterator
        Iterator iterator3 = set.iterator();

        while (iterator3.hasNext())
        {
            System.out.println(iterator3.next());
        }

        //Traversing list elements using ListIterator
        ListIterator listIterator1 = list.listIterator();

        while (listIterator1.hasNext())
        {
            System.out.println(listIterator1.next());
        }

        //Traversing queue and set elements using ListIterator is not possible

        ListIterator listIterator2 = queue.listIterator();    //Compile time error, there is no such method in Queue

        ListIterator listIterator3 = set.listIterator();     //Compile time error, there is no such method in Set
    }
}

2) Using Iterator, we can traverse the elements only in forward direction. But, using ListIterator you can traverse the elements in both the directions – forward and backward. ListIterator has those methods to support the traversing of elements in both the directions.

Iterator Methods :

boolean hasNext() –> Checks whether collection has more elements.

E next()  –> Returns the next element in the collection.

void remove()  –> Removes the current element in the collection i.e element returned by next().

ListIterator Methods :

boolean hasNext() –> Checks whether the list has more elements when traversing the list in forward direction.

boolean hasPrevious() –> Checks whether list has more elements when traversing the list in backward direction.

E next()  –> Returns the next element in the list and moves the cursor forward.

E previous()  –> Returns the previous element in the list and moves the cursor backward.

int nextIndex() –> Returns index of the next element in the list.

int previousIndex() –> Returns index of the previous element in the list.

void remove()  –> Removes the current element in the collection i.e element returned by next() or previous().

void set(E e) –> Replaces the current element i.e element returned by next() or previous() with the specified element.

void add(E e) –> Inserts the specified element in the list.

class IteratorAndListIterator
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<String>();

        list.add("FIRST");

        list.add("SECOND");

        list.add("THIRD");

        //Traversing list elements in forward direction using Iterator

        Iterator iterator = list.iterator();

        while (iterator.hasNext())
        {
            System.out.println(iterator.next());
        }

        //        OUTPUT :
        //        FIRST
        //        SECOND
        //        THIRD

        //Traversing list elements in forward direction using ListIterator

        ListIterator listIterator = list.listIterator();

        while (listIterator.hasNext())
        {
            System.out.println(listIterator.next());
        }

        //        OUTPUT :
        //        FIRST
        //        SECOND
        //        THIRD

        //Traversing list elements in backward direction using ListIterator

        while (listIterator.hasPrevious())
        {
            System.out.println(listIterator.previous());
        }

        //        OUTPUT :
        //        THIRD
        //        SECOND
        //        FIRST
    }
}

3) Using ListIterator, you can obtain index of next and previous elements. But, it is not possible with Iterator interface.

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

class IteratorAndListIterator
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<String>();

        list.add("FIRST");

        list.add("SECOND");

        list.add("THIRD");

        ListIterator listIterator = list.listIterator();

        while (listIterator.hasNext())
        {
            //Getting index of next element

            System.out.println(listIterator.nextIndex()+" : "+listIterator.next());
        }

        //        OUTPUT :
        //        0 : FIRST
        //        1 : SECOND
        //        2 : THIRD

        while (listIterator.hasPrevious())
        {
            //Getting index of previous element

            System.out.println(listIterator.previousIndex()+" : "+listIterator.previous());
        }

        //        OUTPUT :
        //        2 : THIRD
        //        1 : SECOND
        //        0 : FIRST
    }
}

4) Using ListIterator, you can perform modifications(insert, replace, remove) on the list. But, using Iterator you can only remove the elements from the collection.

class IteratorAndListIterator
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<String>();

        list.add("FIRST");

        list.add("SECOND");

        list.add("THIRD");

        ListIterator<String> listIterator = list.listIterator();

        System.out.println(list);       //Output :    [FIRST, SECOND, THIRD]

        while (listIterator.hasNext())
        {
            listIterator.next();

            //Modifying an element returned by next()
            listIterator.set("MODIFIED");
        }

        System.out.println(list);       //Output :    [MODIFIED, MODIFIED, MODIFIED]

        Iterator<String> iterator = list.iterator();

        while (iterator.hasNext())
        {
            iterator.next();

            //Removing an element
            iterator.remove();
        }

        System.out.println(list);    //Output : []
    }
}

5) Using ListIterator, you can iterate a list from the specified index. It is not possible with Iterator.

class IteratorAndListIterator
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<String>();

        list.add("FIRST");

        list.add("SECOND");

        list.add("THIRD");

        list.add("FOURTH");

        list.add("FIFTH");

        //Iterating list from index 2 using ListIterator

        ListIterator<String> listIterator = list.listIterator(2);

        while (listIterator.hasNext())
        {
            System.out.println(listIterator.next());
        }

        //        OUTPUT :
        //        THIRD
        //        FOURTH
        //        FIFTH
    }
}

Different Ways Of Iterating An ArrayList In Java

You can iterate a given ArrayList in 4 different ways. They are,

a) Iteration Using Normal for loop.

b) Iteration Using Iterator Object.

c) Iteration Using ListIterator Object.

d) Iteration Using Enhanced for loop.

Below is the detail description of all of the above methods.

Iteration Using Normal for loop :

This method is useful when you also need index of the elements along with the elements itself. Using this method, you can also iterate a part of an ArrayList. Here is the template for this method.

for (int i = 0; i < list.size(); i++)
{
        type_of_element element = list.get(i);
}

Iteration Using Iterator :

This method is useful when you don’t want index of an element, but you want to remove the elements as you iterate through an ArrayList.

while (iterator.hasNext())
{
    System.out.println(iterator.next());

    //Removing an element from ArrayList
    iterator.remove();
}

Iteration Using ListIterator :

If you want to iterate the list in both the directions – forward and backward, then use the ListIterator method. One more advantage of this method is, you can start iteration from a specific element in an ArrayList.

while (listIterator.hasNext() or listIterator.hasPrevious())
{
    System.out.println(listIterator.next());

        System.out.println(listIterator.previous());
}


Iteration Using Enhanced for loop :

This method is useful when you don’t need indexes of elements and you just want to access the elements without removing them or modifying them (it is the most common case). This method is also short and very easy to write.

for (type_of_element element : list)
{
    System.out.println(element);
}

Here is the program which implements all of the above four methods.

class ArrayListIteration
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        list.add("FIRST");

        list.add("SECOND");

        list.add("THIRD");

        list.add("FOURTH");

        list.add("FIFTH");

        //1. Using for loop

        for (int i = 0; i < list.size(); i++)
        {
            System.out.println(list.get(i));
        }

        //2. Using Iterator

        Iterator<String> it = list.iterator();

        while (it.hasNext())
        {
            System.out.println(it.next());

            //Removing an element from list
            it.remove();
        }

        //3. Using ListIterator

        ListIterator<String> listIt = list.listIterator();

        while (listIt.hasNext())
        {
            System.out.println(listIt.next());
        }

        //4. Using enhanced for loop

        for (String element : list)
        {
            System.out.println(element);
        }
    }
}

Java Programming Examples On ArrayList – 2

7) How do you get the position of a particular element in an ArrayList?

We can use indexOf() and lastIndexOf() methods to find out the position of a given element in an ArrayList. indexOf() method returns index of first occurrence of a specified element where as lastIndexOf() method returns index of last occurrence of a specified element in an ArrayList. If element is not found, they will return -1.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        list.add("JAVA");

        list.add("J2EE");

        list.add("JSP");

        list.add("JAVA");

        list.add("SERVLETS");

        list.add("JAVA");

        list.add("STRUTS");

        System.out.println(list);     //Output : [JAVA, J2EE, JSP, JAVA, SERVLETS, JAVA, STRUTS]

        //Getting the index of first occurrence of "JAVA"

        System.out.println(list.indexOf("JAVA"));     //Output : 0

        //Getting the index of last occurrence of "JAVA"

        System.out.println(list.lastIndexOf("JAVA"));    //Output : 5
    }
}

8) How do you convert an ArrayList to Array?

Using toArray() method of ArrayList class. toArray() method returns an array containing all elements of the ArrayList. This method acts as a bridge between normal arrays and collection framework in java.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        list.add("JAVA");

        list.add("J2EE");

        list.add("JSP");

        list.add("SERVLETS");

        list.add("STRUTS");

        System.out.println(list);      //Output : [JAVA, J2EE, JSP, SERVLETS, STRUTS]

        //getting an array containing all elements of the list.

        Object[] array = list.toArray();

        //Printing the elements of the returned array.

        for (Object object : array)
        {
            System.out.println(object);
        }

//        Output :

//        JAVA
//        J2EE
//        JSP
//        SERVLETS
//        STRUTS
    }
}

9) How do you retrieve an element from a particular position of an ArrayList?

get() method returns an element from a specified position of an ArrayList. This method takes index of the element as an argument.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(111);

        list.add(222);

        list.add(333);

        list.add(444);

        System.out.println(list);     //Output : [111, 222, 333, 444]

        //Getting element at index 3

        System.out.println(list.get(3));    //Output : 444

        //Getting element at index 1

        System.out.println(list.get(1));    //Output : 222
    }
}

10) How do you replace a particular element in an ArrayList with the given element?

set() method replaces a particular element in an Arraylist with the given element. This method takes two arguments. One is the index of the element to be replaced and another one is the element to be placed at that position.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(111);

        list.add(222);

        list.add(333);

        list.add(444);

        System.out.println(list);     //Output : [111, 222, 333, 444]

        //Replacing the element at index 1 with '000'

        list.set(1, 000);

        //Replacing the element at index 3 with '000'

        list.set(3, 000);

        System.out.println(list);   //Output : [111, 0, 333, 0]
    }
}

11) How do you append an element at the end of an ArrayList?

add() method appends an element at the end of an ArrayList.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        list.add("ONE");

        list.add("TWO");

        list.add("THREE");

        list.add("FOUR");

        System.out.println(list);     //Output : [ONE, TWO, THREE, FOUR]
    }
}


12) How do you insert an element at a particular position of an ArrayList?

add() method which takes index and an element as arguments can be used to insert an element at a particular position of an ArrayList. The elements at the right side of that position are shifted one position right i.e indices of right side elements of that position are increased by 1.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        list.add("ONE");

        list.add("TWO");

        list.add("THREE");

        list.add("FOUR");

        System.out.println(list);     //Output : [ONE, TWO, THREE, FOUR]

        //Inserting "AAA" at index 1

        list.add(1, "AAA");

        //Inserting "BBB" at index 3

        list.add(3, "BBB");

        System.out.println(list);    //Output : [ONE, AAA, TWO, BBB, THREE, FOUR]
    }
}

13) How do you remove an element from a particular position of an ArrayList?

remove() method which takes int type as an argument is used to remove an element from a particular position of an ArrayList.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        list.add("AAA");

        list.add("BBB");

        list.add("ccc");

        list.add("DDD");

        list.add("e");

        System.out.println(list);     //Output : [AAA, BBB, ccc, DDD, e]

        //Removing an element from position 2

        list.remove(2);

        System.out.println(list);    //Output : [AAA, BBB, DDD, e]

        //Removing an element from position 3

        list.remove(3);

        System.out.println(list);   //Output : [AAA, BBB, DDD]
    }
}

14) How do you remove the given element from an ArrayList?

remove(Object obj) method removes the first occurrence of the specified element ‘obj‘. If that element doesn’t exist, ArrayList will be unchanged.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        list.add("AAA");

        list.add("BBB");

        list.add("AAA");

        list.add("CCC");

        list.add("BBB");

        System.out.println(list);     //Output : [AAA, BBB, AAA, CCC, BBB]

        //Removing first occurrence of "AAA"

        list.remove("AAA");

        System.out.println(list);    //Output : [BBB, AAA, CCC, BBB]

        //Removing first occurrence of "BBB"

        list.remove("BBB");

        System.out.println(list);   //Output : [AAA, CCC, BBB]
    }
}

15) How do you remove all elements of an ArrayList at a time?

clear() method removes all elements of an ArrayList. ArrayList will be empty after this method is executed.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        list.add("AAA");

        list.add("BBB");

        list.add("AAA");

        list.add("CCC");

        list.add("BBB");

        System.out.println(list);     //Output : [AAA, BBB, AAA, CCC, BBB]

        //Removing all elements of the list

        list.clear();

        System.out.println(list);    //Output : []
    }
}

16) How do you retrieve a portion of an ArrayList?

Using subList() method of ArrayList, we can retrieve a portion of an ArrayList. subList() method returns a view of a portion of an ArrayList in the given range. The returned subList is backed by original ArrayList. That means any changes made to subList will be reflected in original ArrayList or Vice-Versa.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(111);

        list.add(222);

        list.add(333);

        list.add(444);

        list.add(555);

        list.add(666);

        System.out.println(list);     //Output : [111, 222, 333, 444, 555, 666]

        //Retrieving a SubList

        List<Integer> subList = list.subList(1, 4);

        System.out.println(subList);    //Output : [222, 333, 444]

        //Modifying the list

        list.set(2, 000);

        //Changes will be reflected in subList

        System.out.println(subList);    //Output : [222, 0, 444]

        //Modifying the subList

        subList.set(2, 000);

        //Changes will be reflected in list

        System.out.println(list);    //Output : [111, 222, 0, 0, 555, 666]
    }
}

Java Programming Examples On ArrayList – 1

1) Explain the different ways of constructing an ArrayList?

ArrayList can be created in 3 ways.

a) ArrayList() —> It creates an empty ArrayList with initial capacity of 10.

b) ArrayList(int initialCapacity) —> It creates an empty ArrayList with supplied initial capacity.

c) ArrayList(Collection c) —> It creates an ArrayList containing the elements of the supplied collection.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<Integer> list1 = new ArrayList<Integer>();            //First Method

        ArrayList<String> list2 = new ArrayList<String>(20);         //Second Method

        ArrayList<Integer> list3 = new ArrayList<Integer>(list1);      //Third Method
    }
}

2) How do you increase the current capacity of an ArrayList?

ensureCapacity() method can be used to increase the current capacity of an ArrayList. However, capacity of an ArrayList is automatically increased when we try to add more elements than the current capacity. To manually increase the current capacity, ensureCapacity() method is used.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        //Now 'list' can hold 10 elements (Default Initial Capacity)

        list.ensureCapacity(20);

        //Now 'list' can hold 20 elements.
    }
}

3) How do you decrease the current capacity of an ArrayList to the current size?

trimToSize() method is used to trim the capacity of arrayList to the current size of ArrayList. Developers use this method to minimize the storage area of an ArrayList.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();

        //Now 'list' can hold 10 elements (Default Initial Capacity)

        list.ensureCapacity(20);

        //Now 'list' can hold 20 elements.

        list.add("ONE");

        list.add("TWO");

        list.add("THREE");

        list.add("FOUR");

        //reducing the current capacity to current size of an ArrayList.

        list.trimToSize();
    }
}

4) How do you find the number of elements present in an ArrayList?

Using size() method. size() method returns number of elements present in an ArrayList.


public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<Double> list = new ArrayList<Double>();

        list.add(1.1);

        list.add(2.2);

        list.add(3.3);

        list.add(4.4);

        list.add(5.5);

        System.out.println(list);     //Output : [1.1, 2.2, 3.3, 4.4, 5.5]

        System.out.println("Size Of ArrayList = "+list.size());   //Output : Size Of ArrayList = 5
    }
}

5) How do you find out whether the given ArrayList is empty or not?

isEmpty() method of ArrayList can be used to check whether the given ArrayList is empty or not. This method returns true if an ArrayList contains no elements otherwise returns false.

public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<Double> list = new ArrayList<Double>();

        System.out.println(list.isEmpty());    //Output : true
    }
}

Note : You can also use size() method to check whether the given ArrayList is empty or not. size() method returns ‘0’ if an ArrayList is empty.

6) How do you check whether the given element is present in an ArrayList or not?

Using contains() method of ArrayList, we can examine whether the ArrayList contains the given element or not. This method returns true if ArrayList has that element otherwise returns false.


public class MainClass
{
    public static void main(String[] args)
    {
        ArrayList<Double> list = new ArrayList<Double>();

        list.add(1.1);

        list.add(11.11);

        list.add(111.111);

        list.add(1111.1111);

        //Checking whether list conatins '111.1111'

        System.out.println(list.contains(111.1111));    //Output : false
    }
}