Lặp lại thông qua Bộ sưu tập, tránh ConcurrencyModificationException khi xóa các đối tượng trong một vòng lặp

Chúng tôi đều biết bạn không thể làm như sau vì ConcurrentModificationException:

for (Object i : l) {
    if (condition(i)) {
        l.remove(i);
    }
}

Nhưng điều này rõ ràng đôi khi hoạt động, nhưng không phải luôn luôn. Đây là một số mã cụ thể:

public static void main(String[] args) {
    Collection<Integer> l = new ArrayList<>();

    for (int i = 0; i < 10; ++i) {
        l.add(4);
        l.add(5);
        l.add(6);
    }

    for (int i : l) {
        if (i == 5) {
            l.remove(i);
        }
    }

    System.out.println(l);
}

Điều này, tất nhiên, kết quả trong:

Exception in thread "main" java.util.ConcurrentModificationException

Mặc dù nhiều chủ đề không làm điều đó. Dù sao.

Giải pháp tốt nhất cho vấn đề này là gì? Làm thế nào tôi có thể xóa một mục khỏi bộ sưu tập trong một vòng lặp mà không ném ngoại lệ này?

Tôi cũng đang sử dụng một tùy ý Collectionở đây, không nhất thiết là một ArrayList, vì vậy bạn không thể dựa vào get.

Iterator.remove() là an toàn, bạn có thể sử dụng nó như thế này:

List<String> list = new ArrayList<>();

// This is a clever way to create the iterator and call iterator.hasNext() like
// you would do in a while-loop. It would be the same as doing:
//     Iterator<String> iterator = list.iterator();
//     while (iterator.hasNext()) {
for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
    String string = iterator.next();
    if (string.isEmpty()) {
        // Remove the current element from the iterator and the list.
        iterator.remove();
    }
}

Lưu ý rằng đó Iterator.remove()là cách an toàn duy nhất để sửa đổi bộ sưu tập trong quá trình lặp; hành vi không được chỉ định nếu bộ sưu tập cơ bản được sửa đổi theo bất kỳ cách nào khác trong khi quá trình lặp đang diễn ra.

Nguồn: docs.oracle> Giao diện bộ sưu tập

Và tương tự, nếu bạn có ListIteratorvà muốn thêm các mục, bạn có thể sử dụng ListIterator#add, với cùng lý do bạn có thể sử dụng Iterator#remove - nó được thiết kế để cho phép nó.

Trong trường hợp của bạn, bạn đã cố gắng để loại bỏ khỏi danh sách, nhưng những hạn chế cũng áp dụng nếu cố gắng để putthành một Maptrong khi lặp lại nội dung của nó.

Những công việc này:

Iterator<Integer> iter = l.iterator();
while (iter.hasNext()) {
    if (iter.next() == 5) {
        iter.remove();
    }
}

Tôi giả định rằng vì một vòng lặp foreach là cú pháp cú pháp để lặp lại, sử dụng một trình vòng lặp sẽ không giúp ích gì ... nhưng nó mang lại cho bạn .remove()chức năng này .

Với Java 8, bạn có thể sử dụng phương thức mớiremoveIf . Áp dụng cho ví dụ của bạn:

Collection<Integer> coll = new ArrayList<>();
//populate

coll.removeIf(i -> i == 5);

Vì câu hỏi đã được trả lời, cách tốt nhất là sử dụng phương thức remove của đối tượng iterator, tôi sẽ đi vào chi tiết cụ thể về nơi "java.util.ConcurrentModificationException"ném lỗi .

Mỗi lớp bộ sưu tập có một lớp riêng thực hiện giao diện Iterator và cung cấp các phương thức như next(), remove()và hasNext().

Mã cho tiếp theo trông giống như thế này ...

public E next() {
    checkForComodification();
    try {
        E next = get(cursor);
        lastRet = cursor++;
        return next;
    } catch(IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
    }
}

Ở đây phương thức checkForComodificationđược thực hiện như

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

Vì vậy, như bạn có thể thấy, nếu bạn rõ ràng cố gắng loại bỏ một yếu tố khỏi bộ sưu tập. Nó dẫn đến modCountviệc nhận được khác nhau expectedModCount, dẫn đến ngoại lệ ConcurrentModificationException.

Bạn có thể sử dụng iterator trực tiếp như bạn đã đề cập hoặc nếu không thì giữ một bộ sưu tập thứ hai và thêm từng mục bạn muốn xóa vào bộ sưu tập mới, sau đó xóa ALL ở cuối. Điều này cho phép bạn tiếp tục sử dụng loại an toàn của vòng lặp cho mỗi vòng với chi phí sử dụng bộ nhớ và thời gian cpu tăng (không phải là một vấn đề lớn trừ khi bạn có danh sách thực sự lớn hoặc thực sự cũ)

public static void main(String[] args)
{
    Collection<Integer> l = new ArrayList<Integer>();
    Collection<Integer> itemsToRemove = new ArrayList<>();
    for (int i=0; i < 10; i++) {
        l.add(Integer.of(4));
        l.add(Integer.of(5));
        l.add(Integer.of(6));
    }
    for (Integer i : l)
    {
        if (i.intValue() == 5) {
            itemsToRemove.add(i);
        }
    }

    l.removeAll(itemsToRemove);
    System.out.println(l);
}

Trong những trường hợp như vậy, một mẹo phổ biến là (đã?) Để đi ngược lại:

for(int i = l.size() - 1; i >= 0; i --) {
  if (l.get(i) == 5) {
    l.remove(i);
  }
}

Điều đó nói rằng, tôi rất vui khi bạn có các cách tốt hơn trong Java 8, ví dụ removeIfhoặc filtertrên các luồng.

Câu trả lời tương tự như Claudius với một vòng lặp for:

for (Iterator<Object> it = objects.iterator(); it.hasNext();) {
    Object object = it.next();
    if (test) {
        it.remove();
    }
}

Với Bộ sưu tập Eclipse , phương thức removeIfđược định nghĩa trên MutableCollection sẽ hoạt động:

MutableList<Integer> list = Lists.mutable.of(1, 2, 3, 4, 5);
list.removeIf(Predicates.lessThan(3));
Assert.assertEquals(Lists.mutable.of(3, 4, 5), list);

Với cú pháp Lambda Java 8, điều này có thể được viết như sau:

MutableList<Integer> list = Lists.mutable.of(1, 2, 3, 4, 5);
list.removeIf(Predicates.cast(integer -> integer < 3));
Assert.assertEquals(Lists.mutable.of(3, 4, 5), list);

Cuộc gọi đến Predicates.cast()là cần thiết ở đây vì một removeIfphương thức mặc định đã được thêm vào java.util.Collectiongiao diện trong Java 8.

Lưu ý: Tôi là người đi làm cho Bộ sưu tập Eclipse .

Tạo một bản sao của danh sách hiện có và lặp lại trên bản sao mới.

for (String str : new ArrayList<String>(listOfStr))     
{
    listOfStr.remove(/* object reference or index */);
}

Mọi người đang khẳng định người ta không thể xóa khỏi Bộ sưu tập được lặp lại bởi một vòng lặp foreach. Tôi chỉ muốn chỉ ra rằng về mặt kỹ thuật không chính xác và mô tả chính xác (tôi biết câu hỏi của OP rất tiên tiến để tránh sự hiểu biết này) mã đằng sau giả định đó:

for (TouchableObj obj : untouchedSet) {  // <--- This is where ConcurrentModificationException strikes
    if (obj.isTouched()) {
        untouchedSet.remove(obj);
        touchedSt.add(obj);
        break;  // this is key to avoiding returning to the foreach
    }
}

Không phải là bạn không thể xóa khỏi vòng lặp Colletionmà thay vào đó bạn không thể tiếp tục lặp lại sau khi thực hiện. Do đó breaktrong mã ở trên.

Xin lỗi nếu câu trả lời này là trường hợp sử dụng hơi chuyên gia và phù hợp hơn với chủ đề ban đầu tôi đến từ đây, câu hỏi đó được đánh dấu là trùng lặp (mặc dù chủ đề này xuất hiện nhiều sắc thái hơn) và bị khóa.

Với vòng lặp truyền thống

ArrayList<String> myArray = new ArrayList<>();

for (int i = 0; i < myArray.size(); ) {
    String text = myArray.get(i);
    if (someCondition(text))
        myArray.remove(i);
    else
        i++;   
}

A ListIteratorcho phép bạn thêm hoặc xóa các mục trong danh sách. Giả sử bạn có một danh sách các Carđối tượng:

List<Car> cars = ArrayList<>();
// add cars here...

for (ListIterator<Car> carIterator = cars.listIterator();  carIterator.hasNext(); )
{
   if (<some-condition>)
   { 
      carIterator().remove()
   }
   else if (<some-other-condition>)
   { 
      carIterator().add(aNewCar);
   }
}

Tôi có một đề nghị cho vấn đề trên. Không cần danh sách thứ cấp hoặc bất kỳ thời gian thêm. Vui lòng tìm một ví dụ sẽ làm những việc tương tự nhưng theo một cách khác.

//"list" is ArrayList<Object>
//"state" is some boolean variable, which when set to true, Object will be removed from the list
int index = 0;
while(index < list.size()) {
    Object r = list.get(index);
    if( state ) {
        list.remove(index);
        index = 0;
        continue;
    }
    index += 1;
}

Điều này sẽ tránh Ngoại lệ đồng thời.

ConcảnHashMap hoặc ConcurrencyLinkedQueue hoặc ConcảnSkipListMap có thể là một tùy chọn khác, bởi vì họ sẽ không bao giờ ném bất kỳ ConcurrencyModificationException nào, ngay cả khi bạn xóa hoặc thêm mục.

Tôi biết câu hỏi này quá cũ so với Java 8, nhưng đối với những người sử dụng Java 8, bạn có thể dễ dàng sử dụng remove If ():

Collection<Integer> l = new ArrayList<Integer>();

for (int i=0; i < 10; ++i) {
    l.add(new Integer(4));
    l.add(new Integer(5));
    l.add(new Integer(6));
}

l.removeIf(i -> i.intValue() == 5);

Một cách khác là tạo một bản sao của ArrayList của bạn:

List<Object> l = ...

List<Object> iterationList = ImmutableList.copyOf(l);

for (Object i : iterationList) {
    if (condition(i)) {
        l.remove(i);
    }
}

Cách tốt nhất (Được khuyến nghị) là sử dụng gói java.util.Conc hiện. Bằng cách sử dụng gói này, bạn có thể dễ dàng tránh Ngoại lệ này. tham khảo mã sửa đổi

public static void main(String[] args) {
    Collection<Integer> l = new CopyOnWriteArrayList<Integer>();

    for (int i=0; i < 10; ++i) {
        l.add(new Integer(4));
        l.add(new Integer(5));
        l.add(new Integer(6));
    }

    for (Integer i : l) {
        if (i.intValue() == 5) {
            l.remove(i);
        }
    }

    System.out.println(l);
}

Trong trường hợp ArrayList: remove (int index) - if (index là vị trí của phần tử cuối cùng), nó sẽ tránh System.arraycopy()và không mất thời gian cho việc này.

thời gian mảng tăng nếu (chỉ số giảm), bằng cách các yếu tố của danh sách cũng giảm!

cách loại bỏ hiệu quả tốt nhất là- loại bỏ các phần tử của nó theo thứ tự giảm dần: while(list.size()>0)list.remove(list.size()-1);// takes O (1) while(list.size()>0)list.remove(0);// takes O (factorial (n))

//region prepare data
ArrayList<Integer> ints = new ArrayList<Integer>();
ArrayList<Integer> toRemove = new ArrayList<Integer>();
Random rdm = new Random();
long millis;
for (int i = 0; i < 100000; i++) {
    Integer integer = rdm.nextInt();
    ints.add(integer);
}
ArrayList<Integer> intsForIndex = new ArrayList<Integer>(ints);
ArrayList<Integer> intsDescIndex = new ArrayList<Integer>(ints);
ArrayList<Integer> intsIterator = new ArrayList<Integer>(ints);
//endregion

// region for index
millis = System.currentTimeMillis();
for (int i = 0; i < intsForIndex.size(); i++) 
   if (intsForIndex.get(i) % 2 == 0) intsForIndex.remove(i--);
System.out.println(System.currentTimeMillis() - millis);
// endregion

// region for index desc
millis = System.currentTimeMillis();
for (int i = intsDescIndex.size() - 1; i >= 0; i--) 
   if (intsDescIndex.get(i) % 2 == 0) intsDescIndex.remove(i);
System.out.println(System.currentTimeMillis() - millis);
//endregion

// region iterator
millis = System.currentTimeMillis();
for (Iterator<Integer> iterator = intsIterator.iterator(); iterator.hasNext(); )
    if (iterator.next() % 2 == 0) iterator.remove();
System.out.println(System.currentTimeMillis() - millis);
//endregion

• cho vòng lặp chỉ mục: 1090 msec
• cho chỉ số desc: 519 msec --- tốt nhất
• cho vòng lặp: 1043 ms

for (Integer i : l)
{
    if (i.intValue() == 5){
            itemsToRemove.add(i);
            break;
    }
}

Bắt là sau khi loại bỏ phần tử khỏi danh sách nếu bạn bỏ qua lệnh gọi iterator.next () nội bộ. nó vẫn làm việc! Mặc dù tôi không đề xuất viết mã như thế này nhưng nó giúp hiểu được khái niệm đằng sau nó :-)

Chúc mừng!

Ví dụ về sửa đổi bộ sưu tập an toàn chủ đề:

public class Example {
    private final List<String> queue = Collections.synchronizedList(new ArrayList<String>());

    public void removeFromQueue() {
        synchronized (queue) {
            Iterator<String> iterator = queue.iterator();
            String string = iterator.next();
            if (string.isEmpty()) {
                iterator.remove();
            }
        }
    }
}

Tôi biết câu hỏi này giả sử chỉ là một Collection, và không cụ thể hơn bất kỳ List. Nhưng đối với những người đọc câu hỏi này thực sự đang làm việc với một Listtài liệu tham khảo, bạn có thể tránh ConcurrentModificationExceptionbằng một while-loop (trong khi sửa đổi bên trong nó) thay vào đó nếu bạn muốn tránhIterator (hoặc nếu bạn muốn tránh nó nói chung, hoặc tránh nó một cách cụ thể để đạt được một thứ tự lặp khác với dừng từ đầu đến cuối ở mỗi phần tử [mà tôi tin là thứ tự duy nhất Iteratorcó thể làm]):

* Cập nhật: Xem các bình luận bên dưới để làm rõ sự tương tự cũng có thể đạt được với vòng lặp truyền thống .

final List<Integer> list = new ArrayList<>();
for(int i = 0; i < 10; ++i){
    list.add(i);
}

int i = 1;
while(i < list.size()){
    if(list.get(i) % 2 == 0){
        list.remove(i++);

    } else {
        i += 2;
    }
}

Không có đồng thờiExceptionException từ mã đó.

Ở đó chúng ta thấy việc lặp không bắt đầu ngay từ đầu và không dừng lại ở mọi yếu tố (mà tôi tinIterator bản thân nó không thể làm được).

FWIW chúng ta cũng thấy getđược gọi list, điều này không thể thực hiện được nếu tham chiếu của nó chỉ là Collection(thay vì Listkiểu cụ thể hơn Collection) - Listgiao diện bao gồm get, nhưng Collectiongiao diện thì không. Nếu không phải vì sự khác biệt đó, thì listtham chiếu có thể thay vào đó là Collection[và do đó về mặt kỹ thuật, Câu trả lời này sẽ là Câu trả lời trực tiếp, thay vì Câu trả lời tiếp tuyến].

FWIWW cùng mã vẫn hoạt động sau khi được sửa đổi để bắt đầu tại điểm dừng tại mọi phần tử (giống như Iteratorthứ tự):

final List<Integer> list = new ArrayList<>();
for(int i = 0; i < 10; ++i){
    list.add(i);
}

int i = 0;
while(i < list.size()){
    if(list.get(i) % 2 == 0){
        list.remove(i);

    } else {
        ++i;
    }
}

Một giải pháp có thể là xoay danh sách và loại bỏ phần tử đầu tiên để tránh ConcurrencyModificationException hoặc IndexOutOfBoundException

int n = list.size();
for(int j=0;j<n;j++){
    //you can also put a condition before remove
    list.remove(0);
    Collections.rotate(list, 1);
}
Collections.rotate(list, -1);

Hãy thử cái này (loại bỏ tất cả các thành phần trong danh sách bằng nhau i):

for (Object i : l) {
    if (condition(i)) {
        l = (l.stream().filter((a) -> a != i)).collect(Collectors.toList());
    }
}

bạn cũng có thể sử dụng đệ quy

Đệ quy trong java là một quá trình trong đó một phương thức gọi chính nó liên tục. Một phương thức trong java tự gọi nó được gọi là phương thức đệ quy.

đây có thể không phải là cách tốt nhất, nhưng đối với hầu hết các trường hợp nhỏ thì điều này có thể chấp nhận được:

"tạo một mảng trống thứ hai và chỉ thêm những mảng bạn muốn giữ"

_{Tôi không nhớ nơi tôi đã đọc nó từ ... vì sự công bằng tôi sẽ tạo wiki này với hy vọng ai đó tìm thấy nó hoặc chỉ để không kiếm được đại diện mà tôi không xứng đáng.}