yes they are automatically changed.  enemy  is a reference to the object which is in the arraylist.

Actually, there is a way to remove an element from a List inside a loop.
However, it has to be a backwards loop, which starts at the last element and goes back to 1st element.

Take a peek at this post here. Search for the loop inside function draw() in my example code.

you can not remove elemnts from an arraylist , while you iterate over it

This is not strictly true, if you use an iterator then it is possible to iterate over an arraylist of enemy objects then use  and/or remove them in the same loop.
See the code below

1. import java.util.*;
2. ArrayList<String> aList = new ArrayList<String>(); 
3. 
   
4. aList.add("Peter"); 
5. aList.add("Jack"); 
6. aList.add("Jill"); 
7. aList.add("Jack"); 
8. aList.add("Sarah"); 
9. aList.add("Maggie"); 
10. 
    
11. Iterator<String> itr = aList.iterator();
12. while (itr.hasNext()) { 
13.   String element = itr.next(); 
14.   if ("Jack".equals(element)) {
15.     itr.remove();
16.   }
17. } 
18. 
    
19. println(aList); 

whats the finnish method? 

My example doesn't use any extra Iterator! 
And it is JavaScript friendly!
For I don't think Iterator was implemented in Processing.JS yet.
And the way Java things are getting cutting off of it, it never will! 

thanks quarks for your example. It's weird that the advanced for loop causes the error, it is supposed to simplify things!

Advanced/Enhanced/ForEach/ForIn loop does simplify things!
However, not when a Array/ List's size is modified in the middle of such loop!!!

Just a general response to everyone, thanks for all your help!

GoToLoop is right the code you have at line 15 is the for each loop and internally behaves in a similar way as the standard for loop at line 10. In both cases you have effectively got

list.remove(element)

and this alters the size of the list which is not allowed with these constructs.

The ONLY way to safely remove an element while at the same time iterating over the list

I suspect that GoToLoop is also right in that the iterator class has not been implemented in ProcessingJS yet.

So it seems that as long as I go through the ArrayList in reverse order, it's fine, since any removed objects won't affect the upcoming objects in the loop, and the ArrayList's size would be rechecked upon starting the loop again

If by "upcoming" you've meant the next backwards elements, then it is true.
Also, the ArrayList's size is not rechecked in the middle of the loop.
Only when the loop starts all over again!

Let's say the element #10 is removed.
Then, #11 becomes #10, #12 becomes #11, #13 becomes #12, and so on.

The only intact elements are the ones which come before element #10!!!
That's why a loop w/ a reverse iterator works, and a forward one fails!