Java | Iterating through collections using loops and iterators

In Java programming, collections are an important part of any Java program. They allow us to store and manipulate groups of related data in a way that is easy to work with. To access and manipulate the data in these collections, we need to be able to iterate over the contents of the collection. There are two primary ways to do this in Java: using loops and using iterators.

Loops:

In Java, we can use loops to iterate over the contents of a collection. The most common type of loop used for this purpose is the for loop. Here’s an example of how to use a for loop to iterate over an ArrayList of integers:

import java.util.ArrayList;

public class LoopExample {
    public static void main(String[] args) {
        ArrayList<Integer> myArrayList = new ArrayList<Integer>();
        myArrayList.add(1);
        myArrayList.add(2);
        myArrayList.add(3);
        
        for (int i = 0; i < myArrayList.size(); i++) {
            System.out.println(myArrayList.get(i));
        }
    }
}

In this example, we create an ArrayList of integers called myArrayList, add three elements to it, and then use a for loop to iterate over the contents of the list. The loop uses the size() method to determine the number of elements in the list, and the get() method to access each element by its index.

Iterators:

Iterators are another way to iterate over the contents of a collection in Java. An iterator is an object that allows us to traverse a collection one element at a time. Here’s an example of how to use an iterator to iterate over an ArrayList of strings:

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

public class IteratorExample {
    public static void main(String[] args) {
        ArrayList<String> myArrayList = new ArrayList<String>();
        myArrayList.add("apple");
        myArrayList.add("banana");
        myArrayList.add("cherry");
        
        Iterator<String> myIterator = myArrayList.iterator();
        while (myIterator.hasNext()) {
            String element = myIterator.next();
            System.out.println(element);
        }
    }
}

In this example, we create an ArrayList of strings called myArrayList, add three elements to it, and then create an iterator using the iterator() method. We then use a while loop to iterate over the contents of the list. The loop uses the hasNext() method to determine if there are more elements to iterate over, and the next() method to access each element in the list.

Iterators have a number of advantages over loops. For one thing, they allow us to remove elements from the collection as we iterate over it. This can be useful in situations where we need to remove certain elements that meet a certain condition. Here’s an example of how to use an iterator to remove all elements from an ArrayList of integers that are less than 10:

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

public class IteratorExample {
    public static void main(String[] args) {
        ArrayList<Integer> myArrayList = new ArrayList<Integer>();
        myArrayList.add(1);
        myArrayList.add(20);
        myArrayList.add(3);
        myArrayList.add(15);
        
        Iterator<Integer> myIterator = myArrayList.iterator();
        while (myIterator.hasNext()) {
            Integer element = myIterator.next();
            if (element < 10) {
                myIterator.remove();
            }
        }
        
        System.out.println(myArrayList);
    }
}

In this example, we create an ArrayList of integers called myArrayList, add four elements to it, and then use an iterator to iterate over the contents of the list. We check each element to see if it is less than 10, and if it is, we remove it from the list using the remove() method of the iterator. After we have finished iterating over the list, we print out the contents of the list to verify that only the elements greater than or equal to 10 are still present.

Iterators also have a number of methods that allow us to modify the behavior of the iteration. For example, we can use the hasPrevious() and previous() methods to iterate over the elements in a collection in reverse order. We can use the forEachRemaining() method to apply a particular operation to each remaining element in the collection. We can use the nextIndex() and previousIndex() methods to get the index of the next or previous element in the collection.

Conclusion:

Iterating through collections is an essential part of any Java program that involves working with data. In this article, we’ve looked at two primary ways to iterate over the contents of a collection: using loops and using iterators. While loops are simple and easy to use, iterators offer a number of advantages, including the ability to remove elements from the collection as we iterate over it and the ability to modify the behavior of the iteration. Whether you use loops or iterators, it’s important to understand how to iterate over collections in Java in order to be able to work effectively with collections of data.

Leave a Reply Cancel reply