By iX3


2013-08-23 19:00:14 8 Comments

Being somewhat new to the Java language I'm trying to familiarize myself with all the ways (or at least the non-pathological ones) that one might iterate through a list (or perhaps other collections) and the advantages or disadvantages of each.

Given a List<E> list object, I know of the following ways to loop through all elements:

Basic for loop (of course, there're equivalent while / do while loops as well)

// Not recommended (see below)!
for (int i = 0; i < list.size(); i++) {
    E element = list.get(i);
    // 1 - can call methods of element
    // 2 - can use 'i' to make index-based calls to methods of list

    // ...
}

Note: As @amarseillan pointed out, this form is a poor choice for iterating over Lists, because the actual implementation of the get method may not be as efficient as when using an Iterator. For example, LinkedList implementations must traverse all of the elements preceding i to get the i-th element.

In the above example there's no way for the List implementation to "save its place" to make future iterations more efficient. For an ArrayList it doesn't really matter, because the complexity/cost of get is constant time (O(1)) whereas for a LinkedList is it proportional to the size of the list (O(n)).

For more information about the computational complexity of the built-in Collections implementations, check out this question.

Enhanced for loop (nicely explained in this question)

for (E element : list) {
    // 1 - can call methods of element

    // ...
}

Iterator

for (Iterator<E> iter = list.iterator(); iter.hasNext(); ) {
    E element = iter.next();
    // 1 - can call methods of element
    // 2 - can use iter.remove() to remove the current element from the list

    // ...
}

ListIterator

for (ListIterator<E> iter = list.listIterator(); iter.hasNext(); ) {
    E element = iter.next();
    // 1 - can call methods of element
    // 2 - can use iter.remove() to remove the current element from the list
    // 3 - can use iter.add(...) to insert a new element into the list
    //     between element and iter->next()
    // 4 - can use iter.set(...) to replace the current element

    // ...
}

Functional Java

list.stream().map(e -> e + 1); // Can apply a transformation function for e

Iterable.forEach, Stream.forEach, ...

(A map method from Java 8's Stream API (see @i_am_zero's answer).)

In Java 8 collection classes that implement Iterable (for example, all Lists) now have a forEach method, which can be used instead of the for loop statement demonstrated above. (Here is another question that provides a good comparison.)

Arrays.asList(1,2,3,4).forEach(System.out::println);
// 1 - can call methods of an element
// 2 - would need reference to containing object to remove an item
//     (TODO: someone please confirm / deny this)
// 3 - functionally separates iteration from the action
//     being performed with each item.

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
// Same capabilities as above plus potentially greater
// utilization of parallelism
// (caution: consequently, order of execution is not guaranteed,
// see [Stream.forEachOrdered][stream-foreach-ordered] for more
// information about this).

What other ways are there, if any?

(BTW, my interest does not stem at all from a desire to optimize performance; I just want to know what forms are available to me as a developer.)

11 comments

@pippi longstocking 2018-09-06 13:34:26

In java 8 you can use List.forEach() method with lambda expression to iterate over a list.

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

public class TestA {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Apple");
        list.add("Orange");
        list.add("Banana");
        list.forEach(
                (name) -> {
                    System.out.println(name);
                }
        );
    }
}

@iX3 2018-09-10 18:50:38

Cool. Could you explain how this is different from eugene82's answer and i_am_zero's answer?

@pippi longstocking 2018-10-02 06:05:35

@iX3 ahh. Didn't read the whole answer list. Was trying to be helpful.. Do you want to me to remove the answer?

@iX3 2018-10-04 17:33:55

Doesn't matter to me, though perhaps you could improve it by comparing and contrasting it to other techniques. Or if you think it doesn't demonstrate any new technique but might still be useful as a reference for others, perhaps you could add a note explaining that.

@i_am_zero 2016-05-24 09:38:54

In Java 8 we have multiple ways to iterate over collection classes.

Using Iterable forEach

The collections that implement Iterable (for example all lists) now have forEach method. We can use method-reference introduced in Java 8.

Arrays.asList(1,2,3,4).forEach(System.out::println);

Using Streams forEach and forEachOrdered

We can also iterate over a list using Stream as:

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
Arrays.asList(1,2,3,4).stream().forEachOrdered(System.out::println);

We should prefer forEachOrdered over forEach because the behaviour of forEach is explicitly nondeterministic where as the forEachOrdered performs an action for each element of this stream, in the encounter order of the stream if the stream has a defined encounter order. So forEach does not guarantee that the order would be kept.

The advantage with streams is that we can also make use of parallel streams wherever appropriate. If the objective is only to print the items irrespective of the order then we can use parallel stream as:

Arrays.asList(1,2,3,4).parallelStream().forEach(System.out::println);

@iX3 2016-05-24 12:15:00

Thanks for taking the time to add your explanation of this additional method.

@Sudip Bhandari 2018-01-22 10:51:17

You can use forEach starting from Java 8:

 List<String> nameList   = new ArrayList<>(
            Arrays.asList("USA", "USSR", "UK"));

 nameList.forEach((v) -> System.out.println(v));

@Yu Chen 2014-08-25 21:14:30

Right, many alternatives are listed. The easiest and cleanest would be just using the enhanced for statement as below. The Expression is of some type that is iterable.

for ( FormalParameter : Expression ) Statement

For example, to iterate through, List<String> ids, we can simply so,

for (String str : ids) {
    // Do something
}

@ericbn 2014-08-25 21:33:40

He is asking if there any other ways besides the ones described at the question (which include this one you mentioned)!

@CoolMind 2016-11-25 13:12:18

For a backward search you should use the following:

for (ListIterator<SomeClass> iterator = list.listIterator(list.size()); iterator.hasPrevious();) {
    SomeClass item = iterator.previous();
    ...
    item.remove(); // For instance.
}

If you want to know a position, use iterator.previousIndex(). It also helps to write an inner loop that compares two positions in the list (iterators are not equal).

@amarseillan 2015-04-08 19:22:19

The basic loop is not recommended as you do not know the implementation of the list.

If that was a LinkedList, each call to

list.get(i)

would be iterating over the list, resulting in N^2 time complexity.

@iX3 2015-04-08 20:36:47

Correct; that is a good point, and I will update the example in the question.

@Reyske 2016-10-17 12:14:47

according to this post, your statement is not correct :Which is more efficient, a for-each loop, or an iterator?

@amarseillan 2016-10-18 21:07:01

What I read in that post is exactly what I said... What part are you reading exactly?

@eugene82 2014-04-06 17:01:47

A JDK8-style iteration:

public class IterationDemo {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        list.stream().forEach(elem -> System.out.println("element " + elem));
    }
}

@iX3 2014-04-07 19:39:59

Thanks, I intend to update the list at the top with Java 8 solutions eventually.

@nazar_art 2014-12-14 11:37:36

@eugene82 is this approach much more efficient?

@Rogue 2014-12-27 01:57:26

@nazar_art You're not going to see much improvement over anything else unless you perhaps used parallelStream on a very large collection. It's more efficient in the sense of healing verbosity only, really.

@Ted Hopp 2013-08-23 19:29:06

The three forms of looping are nearly identical. The enhanced for loop:

for (E element : list) {
    . . .
}

is, according to the Java Language Specification, identical in effect to the explicit use of an iterator with a traditional for loop. In the third case, you can only modify the list contents by removing the current element, and then only if you do it through the remove method of the iterator itself. With index-based iteration, you are free to modify the list in any way. However, adding or removing elements that come before the current index risks having your loop skipping elements or processing the same element multiple times; you need to adjust the loop index properly when you make such changes.

In all cases, element is a reference to the actual list element. None of the iteration methods makes a copy of anything in the list. Changes to the internal state of element will always be seen in the internal state of the corresponding element on the list.

Essentially, there only two ways to iterate over a list: by using an index or by using an iterator. The enhanced for loop is just a syntactic shortcut introduced in Java 5 to avoid the tedium of explicitly defining an iterator. For both styles, you can come up with essentially trivial variations using for, while or do while blocks, but they all boil down to the same thing (or, rather, two things).

EDIT: As @iX3 points out in a comment, you can use a ListIterator to set the current element of a list as you are iterating. You would need to use List#listIterator() instead of List#iterator() to initialize the loop variable (which, obviously, would have to be declared a ListIterator rather than an Iterator).

@iX3 2013-08-23 19:34:30

OK, thanks, but if the iterator is actually returning a reference to the real element (not a copy) then how can I use it to change the value in the list? I take that if I use an e = iterator.next() then doing e = somethingElse just changes what object e is referring to rather than changing the actual store from which iterator.next() retrieved the value.

@Ted Hopp 2013-08-23 19:58:41

@iX3 - That would be true of an index-based iteration as well; assigning a new object to e won't change what's in the list; you have to call list.set(index, thing). You can change the contents of e (e.g., e.setSomething(newValue)), but to change what element is stored in the list as you are iterating it, you need to stick with an index-based iteration.

@iX3 2013-08-23 20:03:44

Thank you for that explanation; I think I understand what you are saying now and will update my question / comments accordingly. There's no "copying" per-se, but because of the language design in order to make changes to the contents of e I'd have to call one of e's methods because assignment just changes the pointer (pardon my C).

@iX3 2013-08-23 20:21:23

So for lists of immutable types like Integer and String it would not be possible to change the contents using for-each or Iterator methods -- would have to manipulate the list object itself to replace to elements. Is that right?

@Ted Hopp 2013-08-23 20:25:20

@iX3 - Correct. You can remove elements with the third form (explicit iterator), but you can only add elements to or replace elements in the list if you use an index-based iteration.

@iX3 2013-08-23 20:29:38

Thanks again. BTW, it looks like there is a special ListIterator that allows replacement via set. I'm going to add this to the list too.

@Ted Hopp 2013-08-23 20:43:00

@iX3 - Yes, a ListIterator provides both set and add. I should have thought of that.

@iX3 2013-08-23 19:22:20

Example of each kind listed in the question:

ListIterationExample.java

import java.util.*;

public class ListIterationExample {

     public static void main(String []args){
        List<Integer> numbers = new ArrayList<Integer>();

        // populates list with initial values
        for (Integer i : Arrays.asList(0,1,2,3,4,5,6,7))
            numbers.add(i);
        printList(numbers);         // 0,1,2,3,4,5,6,7

        // replaces each element with twice its value
        for (int index=0; index < numbers.size(); index++) {
            numbers.set(index, numbers.get(index)*2); 
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // does nothing because list is not being changed
        for (Integer number : numbers) {
            number++; // number = new Integer(number+1);
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14  

        // same as above -- just different syntax
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            number++;
        }
        printList(numbers);         // 0,2,4,6,8,10,12,14

        // ListIterator<?> provides an "add" method to insert elements
        // between the current element and the cursor
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.add(number+1);     // insert a number right before this
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15

        // Iterator<?> provides a "remove" method to delete elements
        // between the current element and the cursor
        for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            if (number % 2 == 0)    // if number is even 
                iter.remove();      // remove it from the collection
        }
        printList(numbers);         // 1,3,5,7,9,11,13,15

        // ListIterator<?> provides a "set" method to replace elements
        for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
            Integer number = iter.next();
            iter.set(number/2);     // divide each element by 2
        }
        printList(numbers);         // 0,1,2,3,4,5,6,7
     }

     public static void printList(List<Integer> numbers) {
        StringBuilder sb = new StringBuilder();
        for (Integer number : numbers) {
            sb.append(number);
            sb.append(",");
        }
        sb.deleteCharAt(sb.length()-1); // remove trailing comma
        System.out.println(sb.toString());
     }
}

@Mario Rossi 2013-08-23 19:18:52

I don't know what you consider pathological, but let me provide some alternatives you could have not seen before:

List<E> sl= list ;
while( ! sl.empty() ) {
    E element= sl.get(0) ;
    .....
    sl= sl.subList(1,sl.size());
}

Or its recursive version:

void visit(List<E> list) {
    if( list.isEmpty() ) return;
    E element= list.get(0) ;
    ....
    visit(list.subList(1,list.size()));
}

Also, a recursive version of the classical for(int i=0... :

void visit(List<E> list,int pos) {
    if( pos >= list.size() ) return;
    E element= list.get(pos) ;
    ....
    visit(list,pos+1);
}

I mention them because you are "somewhat new to Java" and this could be interesting.

@iX3 2013-08-23 19:25:12

Thanks for mentioning it. I had never looked at the subList method. Yes, I would consider it pathological as I don't know of any circumstance where it would ever be advantageous to use this aside from perhaps obfuscation contests.

@Mario Rossi 2013-08-23 19:32:15

OK. I don't like being called "pathological" so here goes one explanation: I have used them while tracking or following paths in trees. One more? While translating some Lisp programs to Java I didn't want them to lose their Lisp spirit, and did the same. Upvote the comment if you think these are valid, non-pathological uses. I need a group hug!!! :-)

@iX3 2013-08-23 19:37:18

Aren't paths in trees different than lists? BTW, I didn't mean to call you or any person "pathological" I just mean that some answers to my question will be understandably impractical or very unlikely to have value in good software engineering practice.

@Mario Rossi 2013-08-23 19:57:53

@iX3 Don't worry; I was just joking. Paths are lists: "start at the root" (obvious), "move to 2nd child", "move to 1st child", "move to 4th child". "Stop". Or [2,1,4] for short. This is a list.

@AxelH 2017-09-07 09:50:11

I would prefer to create a copy of the list and use while(!copyList.isEmpty()){ E e = copyList.remove(0); ... }. That's more effective than the first version ;).

@shieldgenerator7 2013-08-23 19:07:36

You could always switch out the first and third examples with a while loop and a little more code. This gives you the advantage of being able to use the do-while:

int i = 0;
do{
 E element = list.get(i);
 i++;
}
while (i < list.size());

Of course, this kind of thing might cause a NullPointerException if the list.size() returns 0, becuase it always gets executed at least once. This can be fixed by testing if element is null before using its attributes / methods tho. Still, it's a lot simpler and easier to use the for loop

@iX3 2013-08-23 19:15:14

True...I guess that is technically different, but the behavior is only different if the list is empty, right?

@CPerkins 2013-08-23 19:30:06

@ix3 yes, and in that case, the behavior is worse. I wouldn't call this a good alternative.

@iX3 2013-08-23 19:31:02

Sure, but in fairness, this question is less about what is "good" and more about what is "possible", so I still appreciate this answer.

Related Questions

Sponsored Content

31 Answered Questions

[SOLVED] When to use LinkedList over ArrayList in Java?

28 Answered Questions

[SOLVED] For-each over an array in JavaScript?

77 Answered Questions

[SOLVED] Is Java "pass-by-reference" or "pass-by-value"?

38 Answered Questions

[SOLVED] How to efficiently iterate over each entry in a Java Map?

31 Answered Questions

[SOLVED] How to break out of nested loops in Java?

  • 2009-05-20 09:07:43
  • boutta
  • 965506 View
  • 1579 Score
  • 31 Answer
  • Tags:   java loops

25 Answered Questions

[SOLVED] What is the best way to iterate over a dictionary?

  • 2008-09-26 18:20:06
  • Jake Stewart
  • 1211628 View
  • 2045 Score
  • 25 Answer
  • Tags:   c# dictionary loops

25 Answered Questions

[SOLVED] Why is using "for...in" with array iteration a bad idea?

17 Answered Questions

[SOLVED] Why is char[] preferred over String for passwords?

7 Answered Questions

[SOLVED] Iterate through a HashMap

11 Answered Questions

[SOLVED] Calling remove in foreach loop in Java

Sponsored Content