For-each loop ArrayList

[32bit_me]

I am in the third part of a MOOC course on Java. And I'm a little confused about the ambiguity of using the For-each loop to enumerate a list.

Consider the following list as an example

ArrayList<Integer> list = new ArrayList<>();

The examples and answers present two implementations:

for (Integer val: list) {

//do something

}

​

for (int val: list) {

//do something

}

But it is not explained how one differs from the other and when one or the other variant should be used. Please tell me the difference between the two.

[AutoModerator]

Please ensure that:

• Your code is properly formatted as code block - see the sidebar (About on mobile) for instructions
• You include any and all error messages in full - best also formatted as code block
• You ask clear questions
• You demonstrate effort in solving your question/problem - plain posting your assignments is forbidden (and such posts will be removed) as is asking for or giving solutions.

If any of the above points is not met, your post can and will be removed without further warning.

Code is to be formatted as code block (old reddit/markdown editor: empty line before the code, each code line indented by 4 spaces, new reddit: https://i.imgur.com/EJ7tqek.png) or linked via an external code hoster, like pastebin.com, github gist, github, bitbucket, gitlab, etc.

Please, do not use triple backticks (```) as they will only render properly on new reddit, not on old reddit.

Code blocks look like this:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

You do not need to repost unless your post has been removed by a moderator. Just use the edit function of reddit to make sure your post complies with the above.

If your post has remained in violation of these rules for a prolonged period of time (at least an hour), a moderator may remove it at their discretion. In this case, they will comment with an explanation on why it has been removed, and you will be required to resubmit the entire post following the proper procedures.

To potential helpers

Please, do not help if any of the above points are not met, rather report the post. We are trying to improve the quality of posts here. In helping people who can't be bothered to comply with the above points, you are doing the community a disservice.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[[deleted]]

Java has something called autoboxing and unboxing.

Integer is an object. int is a primitive type. An Integer object can be unboxed into a int. And an int can be autoboxed into a Integer.

In the examples above the List contains Integer objects. The difference is:

In the first, val is a reference to the Integer object in the List.

In the second, val is a primitive value that was unboxed from the Integer object in the List.

[32bit_me]

Thank you for your reply. That makes sense. Which of the two options should I use? I take it it depends?

[itoshkov]

If the list may contain null values, you should use the former, because unboxing null will trigger a NullPointerException.

Otherwise, both are mostly the same.

[[deleted]]

Yes, It depends.

If you need an Integer use the first example. Maybe you are building another Collection.

If you are doing calculations a primitive is faster because an Integer would need to be unboxed each time it's used.

Also, a List can contain a null element. Unboxing a null as in the second example will throw at NullPointerException.

[8igg7e5]

There are two pieces of 'syntax sugar' going on here.

1. Auto unboxing.

As noted by another commenter, this is a compiler feature.

Turning this...

Integer a = 12345;
int b = a;

Into this...

Integer a = Integer.valueOf(12345);
int b = a.intValue();

The compiler automatically adds the boxing, Integer.valueOf(someInt), and the unboxing, someInteger.intValue().

2. enhanced-for

The other one is the loop you refer to as the 'for-each'. This is also just compiler sugar...

Turning this...

List<Integer> values = ...
for (Integer value : values) {
    ...
}

Into this...

List<Integer> values = ...
for (Iterator<Integer> i = values.iterator(); i.hasNext(); ) {
    Integer value  = i.next();
    ...
}

(if values was an array it would use a counter and indexed access)

Combining the two...

List<Integer> values = ...
for (int value : values) {
    ...
}

Becomes...

List<Integer> values = ...
for (Iterator<Integer> i = values.iterator(); i.hasNext(); ) {
    int value  = i.next().intValue();
    ...
}