Modified Concurrent Exception

[spyder]

What is the preferred way to iterate of a collection to modify its elements?

I have only found two solutions:
1) Create a new collection, then select addAll(). After that iterate the new collection
2) Use org.apache.commons.collections.list.CursorableLinkedList
This allows modifications of the list while iterating.

Are there any other solutions? And which is the most preferable?
Because I guess if all work its mainly a performance question.

[Riven]

When you iterate over a Collection with an Iterator, and remove elements, you should get a "Modified Concurrent Exception" as the title suggests.


To answer your question: it depends.

Variables:
 - type of collection
 - size of collection
 - usage of collection

[spyder]

When you iterate over a Collection with an Iterator, and remove elements, you should get a "Modified Concurrent Exception" as the title suggests.

I understand, but I need to loop thru some objects to perform cleanup. As an object cleans up it removes itself from its parent causing the exception.

Variables:
 - type of collection
 - size of collection
 - usage of collection

My most common collections are:
ArrayList or HashSet with approximately 1-20 elements. There is a fair deal of insert and removal, but getting them is most common ofc.

Games published by our own members! Check 'em out!

[Riven]

Have you tried the 'Bag' collection?

It might be exactly what you need.

1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28   29   30   31   32   33   34   35   36   37   38   39   40   41   42   43   44   45   46   47   48   49   50   51   52   53   54   55   56

import java.lang.reflect.Array; import java.util.Arrays; import java.util.Comparator; public class Bag<E> {    private final E[] array;    private int       count;    public Bag(E e, int capacity)    {       this.array = (E[]) Array.newInstance(e.getClass(), capacity);    }    public final int count()    {       return count;    }    public final void put(E e)    {       // no checks... don't grow, just deal with the current capacity      array[count++] = e;    }    public final E swap(int index, E e)    {       E org = array[index];       array[index] = e;       return org;    }    public final E grab(int index)    {       return array[index];    }    public final int search(E e)    {       for (int i = 0; i < count; i++)          if (array[i] == e)             return i;       return -1;    }    public final void dispose(int index)    {       array[index] = array[--count];       array[count + 1] = null;    }    public final void sort(Comparator<E> c)    {       Arrays.sort(array, 0, count, c);    } }

[spyder]

I don't think I can use it, as I don't know the capacity.

[Riven]

To answer your original question then:

ArraysLists are extremely quick to copy around, so that's probably the way to go, don't use iterators though, direct access with get( i ) and remove( i ) is much faster. Enhanced-for is evil.

HashMaps/Sets are fairly expensive to construct and fill, lookup will only be faster than ArrayLists on fairly big collections (~64+ elements or so) especially when the internals are building linkedlists (due to overlapping hashes)

[pepijnve]

If you just want to get rid of the concurrent modification exception you can also use Iterator#remove.

1   2   3   4   5   6   7   8

Collection c; Iterator i = c.iterator(); while(i.hasNext()) {   Object o = i.next();   if (/*should remove o*/) {     i.remove();   } }

[spyder]

Ok, taking all advice into consideration I ended up with this.
What do you think?

1   2   3   4   5   6   7

public void reset(){    Object actorA[] = actors.toArray();    for(int i=0;i<actorA.length;i++){       final Actor a = (Actor) actorA[i];         a.unload();    } }

[Eliwood]

To answer your original question then:

ArraysLists are extremely quick to copy around, so that's probably the way to go, don't use iterators though, direct access with get( i ) and remove( i ) is much faster. Enhanced-for is evil.

HashMaps/Sets are fairly expensive to construct and fill, lookup will only be faster than ArrayLists on fairly big collections (~64+ elements or so) especially when the internals are building linkedlists (due to overlapping hashes)

How much slower are we talking about? I use iterators all over my code because they're cleaner, and because I actually iterate through all elements.

[Riven]

factor 3, overhead.

For LinkedLists, you definitely want Iterators though.

Games published by our own members! Check 'em out!

[tom]

I usually do this when I want to delete elemets from a List:

1   2   3   4   5   6   7

public void reset(){    for (int i=actors.size()-1;i>=0;i--){                 if (/*elemnt should be deleted*/) {                       actors.remove(i);                 }    } }