过滤Java中的列表，同时避免o（n）复杂性导致的ConcurrentModificationException

Question

I found out that apparently iterator.remove() has an o(n) complexity. Anybody, knows of a way of filtering a list while avoiding ConcurrentModificationException without using iterator.remove().

Following is a code snippet showing the difference. It creates a large array list and then deletes large part of it from the middle using it.remove(). Then it does the same thing just this time from the start. On my machine it reads: First test 699962ms Second test 329181ms

clearly a big difference

package src;

import java.util.*;
import java.lang.*;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> a = new ArrayList<Integer>();
        long before, after;

        double elements = Math.pow(10, 3);

        for(int i = 0; i < elements; i++) {
            a.add(i);
        }

        Iterator<Integer> it = a.iterator();
        for(int i = 0; i < elements * 0.4; i++){
            it.next();
        }

        before = System.nanoTime();
        for(int i = 0; i < elements * 0.5; i++){
            it.remove();
            it.next();
        }
        after = System.nanoTime();
        System.out.println(after - before);

        a = new ArrayList<Integer>();
        for(int i = 0; i < elements; i++) {
            a.add(i);
        }


        before = System.nanoTime();
        it = a.iterator();
        it.next();
        for(int i = 0; i < elements * 0.5; i++){
            it.remove();
            it.next();
        }
        after = System.nanoTime();
        System.out.println(after - before);


    }
}

Answer 1

As informed, your benchmark is incorrect. Considering that a single remove from an ArrayList made with either remove() or Iterator.remove() is an O(n) operation (unless removing the last element) due to the resizing of the internal array, the code won't perform well under any circumstances.

A LinkedList would provide you an O(1) removal while iterating it, but you should go for the easiest solution and use List.removeIf() . ArrayList overrides it for O(n) performance and avoids CME too.