Il metodo HashSet <T> .removeAll è sorprendentemente lento

Jon Skeet ha recentemente sollevato un interessante argomento di programmazione sul suo blog: "C'è un buco nella mia astrazione, cara Liza, cara Liza" (enfasi aggiunta):

Ho un set - un HashSet, in effetti. Voglio rimuovere alcuni elementi da esso ... e molti di essi potrebbero non esistere. Infatti, nel nostro caso di prova, nessuno degli elementi nella raccolta "rimozioni" sarà nel set originale. Questo suona - e in effetti è - estremamente facile da codificare. Dopotutto, dobbiamo Set<T>.removeAllaiutarci, giusto?

Specifichiamo la dimensione del set "sorgente" e la dimensione della raccolta "rimozioni" sulla riga di comando, e li costruiamo entrambi. Il set di origine contiene solo numeri interi non negativi; il set di rimozioni contiene solo numeri interi negativi. Misuriamo quanto tempo ci vuole per rimuovere tutti gli elementi utilizzando System.currentTimeMillis(), che non è il cronometro più preciso al mondo ma è più che adeguato in questo caso, come vedrai. Ecco il codice:

import java.util.*;
public class Test 
{ 
    public static void main(String[] args) 
    { 
       int sourceSize = Integer.parseInt(args[0]); 
       int removalsSize = Integer.parseInt(args[1]); 
        
       Set<Integer> source = new HashSet<Integer>(); 
       Collection<Integer> removals = new ArrayList<Integer>(); 
        
       for (int i = 0; i < sourceSize; i++) 
       { 
           source.add(i); 
       } 
       for (int i = 1; i <= removalsSize; i++) 
       { 
           removals.add(-i); 
       } 
        
       long start = System.currentTimeMillis(); 
       source.removeAll(removals); 
       long end = System.currentTimeMillis(); 
       System.out.println("Time taken: " + (end - start) + "ms"); 
    }
}

Cominciamo dandogli un lavoro facile: un set sorgente di 100 elementi e 100 da rimuovere:

c:UsersJonTest>java Test 100 100
Time taken: 1ms

Ok, quindi non ci aspettavamo che fosse lento ... chiaramente possiamo accelerare un po 'le cose. Che ne dici di una fonte di un milione di elementi e 300.000 elementi da rimuovere?

c:UsersJonTest>java Test 1000000 300000
Time taken: 38ms

Hmm. Sembra ancora abbastanza veloce. Ora sento di essere stato un po 'crudele, chiedendogli di fare tutta quella rimozione. Rendiamolo un po 'più semplice: 300.000 elementi di origine e 300.000 rimozioni:

c:UsersJonTest>java Test 300000 300000
Time taken: 178131ms

Mi scusi? Quasi tre minuti ? Yikes! Sicuramente dovrebbe essere più facile rimuovere oggetti da una raccolta più piccola di quella che abbiamo gestito in 38 ms?

Qualcuno può spiegare perché sta succedendo? Perché il HashSet<T>.removeAllmetodo è così lento?

Il comportamento è (in qualche modo) documentato nel javadoc :

Questa implementazione determina quale è il più piccolo di questo set e della raccolta specificata, richiamando il metodo size su ciascuno. Se questo set ha meno elementi , l'implementazione esegue l'iterazione su questo set, controllando a turno ogni elemento restituito dall'iteratore per vedere se è contenuto nella raccolta specificata . Se è così contenuto, viene rimosso da questo set con il metodo di rimozione dell'iteratore. Se la raccolta specificata ha meno elementi, l'implementazione esegue l'iterazione sulla raccolta specificata, rimuovendo da questo set ogni elemento restituito dall'iteratore, utilizzando il metodo remove di questo set.

Cosa significa in pratica, quando chiami source.removeAll(removals);:

• se la removalsraccolta è di dimensioni inferiori a source, viene chiamato il removemetodo di HashSet, che è veloce.

• se la removalsraccolta è di dimensioni uguali o maggiori di source, removals.containsviene chiamato, il che è lento per un ArrayList.

Soluzione rapida:

Collection<Integer> removals = new HashSet<Integer>();

Nota che c'è un bug aperto che è molto simile a quello che descrivi. La linea di fondo sembra essere che probabilmente è una scelta sbagliata ma non può essere modificata perché è documentata in javadoc.

Per riferimento, questo è il codice di removeAll(in Java 8 - non ho controllato altre versioni):

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    boolean modified = false;

    if (size() > c.size()) {
        for (Iterator<?> i = c.iterator(); i.hasNext(); )
            modified |= remove(i.next());
    } else {
        for (Iterator<?> i = iterator(); i.hasNext(); ) {
            if (c.contains(i.next())) {
                i.remove();
                modified = true;
            }
        }
    }
    return modified;
}