How to iterate over a list in various ways in java / Different methods of list iteration in java

On:

Iterating over a collection is a task that most developers are required to perform during their development task and most of us keep on using the same way which we have used earlier though there are many ways to do this.
In this post I am going to list down all those ways. We all might be familiar with these ways.
Still, keep on reading to refresh!!!

First let’s initialize a list

List list = Arrays.asList(new String[]{
              "first","second","third","fourth", "fifth"
            });

Now let’s begin iteration:

Method 1: Using for loop

for (int count = 0; count < list.size(); count++) {
   System.out.println("Item:: " + list.get(count));
}


Detail
Iterate over the list using a for loop which runs from 0 to the total number of list elements - 1. This is because elements of the list are indexed from 0.
In every iteration, retrieve the current list element using its get method. get accepts the index as argument and returns the element at that index.

Method 2: Using advanced for loop(for-each loop)

for (String s : list) {
   System.out.println("Item:: " + s);
}

Detail
This example uses an enhanced for loop to iterate over a collection. In this loop, the loop variable has the current list item as its value and it should be of the same type as the elements of the list, which is a String in this case.

Method 3: Using java.util.Iterator

Iterator iterator = list.iterator();
while (iterator.hasNext()) {
   System.out.println("Item:: " + iterator.next());
}

Detail
This method uses a java.util.iterator to iterate over the list. You can get an iterator over the list using its iterator() method.
An iterator has a next() method which returns the list element at the current iterator position. It also contains hasNext() method which returns true if the list has any more elements after the current iterator position.
This method is primarily used for iterating over a Set.

Method 4: Using java8

list.forEach(new Consumer() {
   public void accept(String s) {
	System.out.println("Item :: "+s);
   }
});

Detail
 forEach method of java.lang.Iterable interface is used to loop over a collection. This method takes a java.util.function.Consumer interface object which has an accept method.
accept takes a single argument and returns nothing. In each iteration, we are passing an element to this method and printing it out to the console.

There is another variant of above method which uses Lambda expression as:

list.forEach(s -> {
   s = "Item :: " + s;
   System.out.println(s);
});

Detail: Since java.util.function.Consumer interface is a Functional interface, we may use Lambda Expression where this interface type is expected as an argument. forEach method of java.lang.Iterableexpects a java.util.function.Consumertype in its accept method. Hence, we are passing Lambda Expression to perform the same task.

Method 5: Iterate list java 8

list.stream().forEach(s -> {
   s = "Item :: " + s;
   System.out.println(s);
});

Detail
Similar to the above method, we are utilizing a stream over the list object. stream() method is a new addition to java.util.Collection interface in java 8 and is a
default interface method which returns a java.util.stream.Stream instance.
java.util.stream.Stream has a forEach method which accepts a java.util.function.Consumer object as an argument. Rest functionality is the same as Method 4 above.
Method 6: Using a ListIterator
This method is similar to using an iterator. java.util.List has a listIterator() method which returns a java.util.ListIterator for iterating over a list.
ListIterator also contains hasNext() and next() methods which are used for list iteration as shown below.

ListIterator iterator = list.listIterator();
while (iterator.hasNext()) {
   System.out.println("Item:: " + iterator.next());
}

An advantage of using a ListIterator is that it can also be used to iterate a list in reverse order as opposed to a conventional iterator.

Let’s tweak in

  1. Method 1 may throw ArrayIndexOutOfBoundsException if you do a get(count) and count exceeds size of list.
  2. Method 3 is primarily used for iterating over a set since, unlike a List, a Set does NOT have a get() method to get its individual elements.
  3. When using iterator always check the condition using hasNext method of iterator.
    Never check null on next() method (like if(iterator.next() != null)) since next() method will return a list element and  move the iterator to the next element.
    Thus, you will not be able to get the previous element.
    Further, when there are no elements left to iterate, then next() throws a java.util.NoSuchElementException and therefore you can not use it to check for a terminating condition.
  4. Method 4 uses forEach method of java.util.Iterable interface. This is a default method added in this interface since java8.
  5. Methods 4 and 5 may only be used when you are using java 8 for development.
  6. Method 5 utilizes java.util.stream.Stream to iterate over a collection and is a powerful feature introduced in java 8.
    Using streams we may completely cut down iteration code when an element meeting a certain condition is required out of collection.
    For Example, from an employee list, if I need to get an employee with a particular id. To know how, check this out.


Click the clap below if you liked the article.

Leave a Reply