迭代此集合时如何避免ConcurrentModificationException？

Question

I need to iterate over a collection of items & sometimes add to that collection at the same time. However, incase I add while iterating then I just start the iteration from fresh by breaking out of iteration loop & restarting iteration from beginning. However this leads to ConcurrentModificationException . [code below]

    List<Integer> collection = new ArrayList<>();
    for (Integer lobId: collection) {
         ..
         if (someCondition) {
             collection.add(something); 
             break; 
         }
    }

How could I possibly do something like above avoiding ConcurrentModificationException ?

Would it be correct to simply use an Array instead of ArrayList to avoid this exception ? Is there any type of specialized collection for this ?

--

Edit:

I dont want to create a new copy for this arraylist because I'm repeating this entire iteration process multiple times unless some requirement is completed. Creating a new copy each time would bring in some extra overhead, which I would like to avoid if somehow possible.

Also if possible I would like to maintain a sorted order & unique values in that collection. Is there anything that is ready to use in any library? Otherwise I could sort it at the end of iteration process & remove duplicates. That will also do fine for me.

Answer 1

Use another collection for the additions and combine them at the end.

List<Integer> collection = new ArrayList<>();
collection.add(...)
...
List<Integer> tempCollection = new ArrayList<>();    
for (Integer lobId: collection ) {
     ..
     if (someCondition) {
         tempCollection.add(something); 
         break; 
     }
}

collection.addAll(tempCollection);

Answer 2

这段代码不能导致ConcurrentModificationException，因为在你添加一个元素之后你就破坏了循环并且不再使用迭代器了

Answer 3

ConcurrentModificationException basically means that you're iterating over a Collection with one iterator (albeit implicitly defined by your enhanced for loop) and invalidating it on the fly by changing the Collection itself. You can avoid this by doing the modifications via the same iterator :

List<Integer> collection = new ArrayList<>();
ListIterator<Integer> iter = collection.listIterator();
while (iter.hasNext()) {
     Integer currVal = iter.next();
     if (someCondition) {
         iter.add(something); // Note the addition is done on iter
         break; 
     }
}

Answer 4

if I understand you right, you want to iterate over the list , if some condition , you want to break the iteration , and an item and start fresh .

In the case do this:

   List<Integer> collection = new ArrayList<>();
   boolean flag = false;
   Integer item = 
    for (Integer lobId: collection) {
         ..
         if (someCondition) {
             flag = true;
             item = something; 
             break; 
         }
    }

   if (flag){
      collection.add(item);
   }

if someone else is going to change the list outside out loop - you will need to sync those access - read iterator thread safe , and use the other answers here like copying the list or some other copy on write

Answer 5

不要每个使用，使用好旧

for(int i=0; i<collection.size();i++)