在一个类中遍历arraylist，而在另一类中添加元素

Question

i'm getting a concurrentmodification exception, the problem is that i'm iterating through an arrayList and drawing and updating the sprites in the arraylist, while adding new sprites in another java class.

public abstract class Scene
{
    ArrayList<UIElement> uiElements = new ArrayList<>();
    ArrayList<GameObject> sprites = new ArrayList<>();

    public ArrayList<GameObject> getSprites()
    {
        return sprites;
    }

    public ArrayList<UIElement> getUiElements()
    {
        return uiElements;
    }

    public abstract void load();

    public abstract void unload();

    public void update()
    {
        sprites.forEach(GameObject::update);
        uiElements.forEach(UIElement::update);
    }

    public void draw(Graphics2D g2)
    {
        sprites.forEach(e -> e.draw(g2));

        uiElements.forEach(e -> e.draw(g2));
    }

}

so these are the iterating methods in the java class named Scene.java

    public void onButtonsEvent(WiimoteButtonsEvent wiimoteButtonsEvent)
    {
//      shoot firebolt when button b is held
        if(  wiimoteButtonsEvent.isButtonBHeld())
        {
            if(updateIndexTwo % UPDATE_SPEED == 0)
            {
                Vector2D fireboltVector = new Vector2D(vector.getX()+SPRITE_WIDTH/2, vector.getY(), crossHair.getX() + CH_SIZE/2, crossHair.getY() + CH_SIZE/2);
                Firebolt firebolt = new Firebolt(fireboltVector, damage, color, scene);
                scene.getSprites().add(firebolt);
                updateIndexTwo = 0;
            }
            updateIndexTwo++;
        }
    }

this is the code where the Firebolt(sprite) will be added to the sprites arraylist in Scene

Answer 1

i'm getting a concurrentmodification exception, the problem is that i'm iterating through an arrayList and drawing and updating the sprites in the arraylist, while adding new sprites in another java class.

The basic solution is fairly simple: don't do that. It is an intentional design feature that if an ArrayList is structurally modified, then any iterators over that list that were obtained prior to the modification are invalidated; further use of them causes ConcurrentModificationException to be thrown. This happens whether you're using Iterator s directly, using an enhanced for loop, or using forEach() . The other basic collections classes ( LinkedList , HashSet , etc.) all work the same way.

If indeed you must accommodate the collection being modified without breaking an ongoing iteration over it, then you need a collection class that accomodates such activity. For example, you could consider ConcurrentLinkedDeque , or one of the other collections from java.util.concurrent . It is possible to write your own, but it's tricky, and why do that when there are existing classes in the standard library that will serve?

Note also that although a solution can be found in java.util.concurrent, the problem does not depend on multiple threads being involved. In fact, if you do have multiple threads then using one of the concurrent collections serves a dual purpose: it also ensures consistent operations on the collection without need of external synchronization. If by any chance you were previously accessing the list from multiple threads without proper synchronization then getting the CME was a lucky break -- you might instead have just gotten silent malfunction.

Answer 2

Look at an existing thread safe class such as ArrayBlockingQueue. You can wrap your ArrayList in synchronization code but it's easier to use a data structure that already does what you want.