CODEWITHSUNDEEP
javaiteratorconcurrentmodification
Jason
Jason

Reputation: 11363

Why does one loop throw a ConcurrentModificationException, while the other doesn't?

I've run into this while writing a Traveling Salesman program. For an inner loop, I tried a 

for(Point x:ArrayList<Point>) {
// modify the iterator
}

but when adding another point to that list resulted in a ConcurrentModicationException being thrown.

However, when I changed the loop to 

for(int x=0; x<ArrayList<Point>.size(); x++) {
// modify the array
}

the loop ran fine without throwing an exception.

Both a for loops, so why does one throw an exception while the other does not?

Upvotes: 10

Views: 5801

Answers (5)

Damian
Damian

Reputation: 550

If you run the code and observe you find that first iteration of the loop works fine but the second throws ConcurrentModicationException

if is because next() method checks if the number of the elements did not change.

For nice explanation see http://javaadami.blogspot.com/2007/09/enhanced-for-loop-and.html

Upvotes: 0

Martin
Martin

Reputation: 38289

As others explained, the iterator detects modifications to the underlying collection, and that is a good thing since it is likely to cause unexpected behaviour.

Imagine this iterator-free code which modifies the collection:

for (int x = 0; list.size(); x++)
{
  obj = list.get(x);
  if (obj.isExpired())
  {
    list.remove(obj);
    // Oops! list.get(x) now points to some other object so if I 
    // increase x again before checking that object I will have 
    // skipped one item in the list
  }
}

Upvotes: 10

fastcodejava
fastcodejava

Reputation: 41087

You cannot modify a List while you are iterating over it which you are doing in the first example. In the second you simply have a regular for loop.

Upvotes: 0

Persimmonium
Persimmonium

Reputation: 15791

the first code is using an iterator so modifying the collection is not allowed. The second code you are accessing each object with x.get(i), so not using an iterator, modifications thus are allowed

Upvotes: 2

Jim Blackler
Jim Blackler

Reputation: 23169

The first example uses an iterator, the second does not. It is the iterator that checks for concurrent modification.

Upvotes: 7

Related Questions