ループでオブジェクトを削除するときにConcurrentModificationExceptionを回避して、コレクションを反復処理する

私たちは皆、あなたが次の理由で次のことができないことを知っていますConcurrentModificationException：

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

しかし、これは明らかに機能することもありますが、常に機能するとは限りません。ここにいくつかの特定のコードがあります：

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);
}

もちろん、これは次の結果になります。

Exception in thread "main" java.util.ConcurrentModificationException

複数のスレッドが実行していない場合でも。とにかく。

この問題の最良の解決策は何ですか？この例外をスローせずに、ループでコレクションからアイテムを削除するにはどうすればよいですか？

Collectionここでも任意のを使用してArrayListいますが、必ずしもとは限らないため、に依存することはできませんget。

Iterator.remove() 安全です。次のように使用できます。

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();
    }
}

Iterator.remove()反復中にコレクションを変更する唯一の安全な方法であることに注意してください。反復の進行中に基になるコレクションが他の方法で変更された場合の動作は規定されていません。

出典：docs.oracle>コレクションインターフェース

同様に、があり、アイテムListIteratorを追加したい場合はListIterator#add、同じ理由でを使用できますIterator#remove 。これは、それを許可するように設計されています。

あなたの場合、リストから削除しようとしputましたMapが、コンテンツを反復しながらしばらくしようとした場合にも同じ制限が適用されます。

これは機能します：

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

foreachループは反復のための構文シュガーであるため、反復子を使用しても役に立たないと想定しましたが、この.remove()機能は提供されます。

Java 8では、新しいremoveIfメソッドを使用できます。あなたの例に適用：

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

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

質問はすでに回答済みです。つまり、イテレータオブジェクトのremoveメソッドを使用するのが最善の方法なので、エラー"java.util.ConcurrentModificationException"がスローされる場所の詳細に行きます。

すべてのコレクションクラスには、Iteratorインターフェースを実装しnext()、remove()およびのようなメソッドを提供するプライベートクラスがありhasNext()ます。

次のコードは次のようになります...

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

ここでメソッドcheckForComodificationは次のように実装されます

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

ご覧のとおり、コレクションから要素を明示的に削除しようとすると、その結果、とmodCountは異なりexpectedModCount、例外が発生しますConcurrentModificationException。

あなたが言及したようにイテレータを直接使用するか、2番目のコレクションを保持して、削除する各項目を新しいコレクションに追加し、最後にremoveAllを追加します。これにより、メモリ使用量とCPU時間の増加を犠牲にして、for-eachループのタイプセーフを使い続けることができます（本当に、本当に大きなリストまたは本当に古いコンピューターでない限り、大きな問題にはなりません）。

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);
}

そのような場合、一般的なトリックは（そうでしたか？）後退することです：

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

そうは言っても、Java 8で、removeIfまたはfilterストリーム上など、より良い方法があることは私にとって非常に嬉しいことです。

forループを使用したClaudiusと同じ答え：

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

Eclipseのコレクション、法removeIfに規定されMutableCollectionは動作します：

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);

Java 8 Lambda構文では、次のように記述できます。

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);

Java 8のインターフェースにPredicates.cast()デフォルトのremoveIfメソッドが追加されたため、ここでの呼び出しが必要ですjava.util.Collection。

注：私はEclipseコレクションのコミッターです。

既存のリストのコピーを作成し、新しいコピーを繰り返します。

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

人々は、foreachループによって反復されているコレクションから削除できないと主張しています。技術的に正しくないことを指摘して正確に説明したいと思います（OPの質問は非常に進んでいるため、これを知る必要がありません）。

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
    }
}

反復から削除できないのではなく、Colletion一度実行すると反復を続行できません。したがって、break上記のコードで。

この回答がやや専門的なユースケースであり、私がここに到着した元のスレッドにより適している場合、お詫び申し上げます。これは、このスレッドの複製としてマークされ（このスレッドは微妙に見えます）、ロックされています。

従来のforループ

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をListIterator使用すると、リスト内のアイテムを追加または削除できます。Carオブジェクトのリストがあるとします：

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);
   }
}

上記の問題について提案があります。二次リストや追加の時間は必要ありません。同じことを異なる方法で行う例を見つけてください。

//"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;
}

これにより、同時実行例外が回避されます。

ConcurrentHashMap、ConcurrentLinkedQueue、またはConcurrentSkipListMapは、アイテムを削除または追加しても、ConcurrentModificationExceptionをスローしないため、別のオプションになる場合があります。

私はこの質問がJava 8については古すぎることを知っていますが、Java 8を使用している人は簡単にremoveIf（）を使用できます。

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);

別の方法は、arrayListのコピーを作成することです。

List<Object> l = ...

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

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

最良の方法（推奨）は、java.util.Concurrentパッケージの使用です。このパッケージを使用すると、この例外を簡単に回避できます。変更されたコードを参照

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);
}

場合ArrayListを：削除（int型のインデックス） - （インデックスが最後の要素の位置である）、それはせずに回避した場合System.arraycopy()や、このための時間がないかかります。

リストの要素も減少するので、（インデックスが減少する）if arraycopy時間は増加します！

最も効果的な削除方法は、その要素を降順で削除することです。// while(list.size()>0)list.remove(list.size()-1);O（1）を while(list.size()>0)list.remove(0);とる// 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

• インデックスループの場合：1090ミリ秒
• descインデックスの場合：519ミリ秒---最高
• イテレータの場合：1043ミリ秒

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

キャッチは、内部のiterator.next（）呼び出しをスキップした場合にリストから要素を削除した後です。それでも動作します！このようなコードを書くことは提案しませんが、その背後にある概念を理解するのに役立ちます:-)

乾杯！

スレッドセーフコレクションの変更例：

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();
            }
        }
    }
}

私はこの質問が単にCollection特定のものではなく、単に仮定していることを知っていますList。しかし、実際にList参照で作業しているこの質問を読んでいる人にとっては、回避ConcurrentModificationExceptionしwhileたいIterator場合（一般にそれを回避したい場合、または具体的にそれを回避したい場合）に-loop を使用して回避できます（その中で変更します）。開始から終了までの各要素での停止とは異なるループ順序（これは、Iteratorそれ自体が実行できる唯一の順序であると私は信じています）：

*更新：従来の -for-loop でも同様のことが実現可能であることを明確にする以下のコメントを参照してください。

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;
    }
}

そのコードからのConcurrentModificationExceptionはありません。

ループは最初から始まらず、すべての要素で止まらないことがわかります（私はIteratorそれ自体はできないと思います）。

FWIW getが呼び出されていることもわかります。list参照がCollection（より具体的なList-typeの代わりに）だけの場合は実行できませんでしたCollection- Listインターフェースにgetはが含まれていCollectionますが、インターフェースには含まれていません。その違いがなければ、list参照は代わりにCollection[したがって、厳密に言えば、この回答は接線回答ではなく直接回答になります]。

FWIWW同じコードは、変更後もすべての要素で停止から開始するように機能します（Iterator順序と同様）。

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;
    }
}

1つの解決策は、リストをローテーションして最初の要素を削除して、ConcurrentModificationExceptionまたはIndexOutOfBoundsExceptionを回避することです。

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);

これを試してください（リスト内のに等しいすべての要素を削除しますi）：

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

再帰も使用できます

Javaでの再帰は、メソッドがそれ自体を継続的に呼び出すプロセスです。自身を呼び出すJavaのメソッドは、再帰的メソッドと呼ばれます。

これは最良の方法ではないかもしれませんが、ほとんどの場合、これは許容できるはずです。

「2番目の空の配列を作成し、保持したいものだけを追加します」

_{私はこれをどこから読んだか覚えていません...正直なところ、このウィキは誰かがそれを見つけられるように、または私が値するはずの担当者を獲得しないために作ります。}