we can also retrieve elements of an arraylist using a loop instead of iterator

[Monica Shiralkar]

we can also retrieve elements of an arraylist using a loop instead of iterator.whats the difference then? whats wrong in fetching arralist elements using loop?

thanks..

[Emanuel Kadziela]

Let me confirm that this is what you mean:

Loop:

List list = new ArrayList();
for (Object o:list)
{
//do stuff with o
}

Iterator:

List list = new ArrayList();
Iterator iter = list.iterator();
while (iter.hasNext())
{
Object o = iter.next();
//do stuff with o
}

If this is indeed what you're talking about, then there isn't much difference.

[Campbell Ritchie]

 

Emanuel Kadziela wrote: . . .
Loop:

List list = new ArrayList();
for (Object o:list)
{
//do stuff with o
}

Iterator:

List list = new ArrayList();
Iterator iter = list.iterator();
while (iter.hasNext())
{
Object o = iter.next();
//do stuff with o
}

If this is indeed what you're talking about, then there isn't much difference.

There is hardly any difference. The first form, the for‑each (enhanced for) loop is syntactic sugar for something like this (I think I have got this bit right):-

List<XXX> list = new XYZList<XXX>();
list.add(...);
for (Iterator<XXX> it = list.iterator(); it.hasNext(); /*blank*/)
{
XXX x = it.next();
//do stuff with x
}

So both use loops. We already know that the two conventional ways to iterate a collection are
Iterator<XXX> it = coll.iterator; while(it.hasNext())...
and
for (Iterator<XXX> it = coll.iterator; it.hasNext(); )...
So what you have seen are simply the two conventional ways to use an Iterator, one of them being “hidden” behind the for‑each loop.

What you have forgotten is hinted at here. You have a tagging interface which suggests you can use this form of for loop:-

for (int i = 0; i < list.size(); i++)
{
XXX x = list.get(i);
//do stuff with x
}

You will have seen the similarity to a conventional for loop to iterate an array. This only works well if the list is backed by an array. But we know that access to element 123456789 of an array is as fast as access to element 1. That is what “random” access means. So you see the javadoc link I gave you contradicts the conventional advice always to use an Iterator. It tells you all about it. It works very badly for linked lists, and very well for lists backed by an array, so you can combine the two:-

List<XXX> xxxList = new ???List<XXX>();
xxxList.add(...);
if (xxxList instanceof RandomAccess)
/* copied and pasted from earlier */
{
for (int i = 0; i < list.size(); i++)
{
XXX x = list.get(i);
//do stuff with x
}
}
else
{
for (Iterator<XXX> it = list.iterator(); it.hasNext(); /*blank*/)
{
XXX x = it.next();
//do stuff with x
}
}

I think that is what you meant about two kinds of loop.

[Tony Docherty]

 

If this is indeed what you're talking about, then there isn't much difference.

Both these code snippets use the list's Iterator so I'm not sure if it is what the OP meant. I suspect they were talking about the difference between an Iterator and a standard for loop.
You are correct in that there isn't much difference but there is a small important difference between the two and that is by directly using an iterator you can use it to safely remove the current loop object from the list and still continue to iterate over the list. You can't do this when using a for-each loop.

The for loop implementation is different in that you use the get() method to directly retrieve the object at the given index. This means you can do things like get adjacent objects for comparison; get every nth object; get objects in reverse order etc etc.

[Paul Clapham]

 

Tony Docherty wrote:The for loop implementation is different in that you use the get() method to directly retrieve the object at the given index. This means you can do things like get adjacent objects for comparison; get every nth object; get objects in reverse order etc etc.

And in this case, it makes a performance difference if you use a LinkedList versus an ArrayList when you use get(n) to retrieve the object at index n. (I believe it's O(N) for the ArrayList versus O(N^2) for the LinkedList.) Whereas using the Iterator for either kind of list provides O(N) performance.

[Campbell Ritchie]

For an arrayed list, which usually implements the RandomAccess interface, finding the object at position i runs in constant time, so iterating the whole list like that is linear time. It would usually be linear time to find an element in for a linked list, but iterating the whole linked list is quadratic time (I did say yesterday, “It works very badly for linked lists”).
The advantage of using the Iterator on a linked list is that going from item i to item i + 1 is constant time, whereas finding item i with get(i) is much slower.
Another advantage of get() on an arrayed list is that you can iterate part of the list, maybe starting in the middle.