Qual è la differenza tra ArrayList.clear () e ArrayList.removeAll ()?

Supponendo che arraylistsia definito come ArrayList<String> arraylist, è arraylist.removeAll(arraylist)equivalente a arraylist.clear()?

In tal caso, posso supporre che il clear()metodo sia più efficiente per svuotare l'elenco di array?

Ci sono avvertenze nell'uso arraylist.removeAll(arraylist)invece di arraylist.clear()?

Il codice sorgente per clear():

public void clear() {
    modCount++;

    // Let gc do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

Il codice sorgente per removeAll()(come definito in AbstractCollection):

public boolean removeAll(Collection<?> c) {
    boolean modified = false;
    Iterator<?> e = iterator();
    while (e.hasNext()) {
        if (c.contains(e.next())) {
            e.remove();
            modified = true;
        }
    }
    return modified;
}

clear() è molto più veloce poiché non ha a che fare con tutte quelle chiamate di metodo extra.

E come sottolinea Atrey, c.contains(..)aumenta la complessità temporale di removeAlla O (n ² ) rispetto a clearO (n).

La complessità temporale di ArrayList.clear()is O(n)e of removeAllis O(n^2).

Quindi sì, ArrayList.clearè molto più veloce.

Il clear()metodo rimuove tutti gli elementi di un singolo ArrayList. È un'operazione veloce, in quanto imposta semplicemente gli elementi dell'array su null.

Il removeAll(Collection)metodo, da cui è ereditato AbstractCollection, rimuove tutti gli elementi presenti nella raccolta argomenti dalla raccolta su cui si chiama il metodo. È un'operazione relativamente lenta, poiché deve cercare in una delle raccolte coinvolte.

A meno che non ci sia un'ottimizzazione specifica che controlla se l'argomento passato removeAll()è la raccolta stessa (e dubito fortemente che tale ottimizzazione sia presente) sarà significativamente più lenta di una semplice .clear().

A parte questo (e almeno altrettanto importante): arraylist.removeAll(arraylist)è solo un codice ottuso e confuso. È un modo molto arretrato di dire "cancella questa raccolta". Quale vantaggio avrebbe rispetto al molto comprensibile arraylist.clear() ?

Servono a scopi diversi. clear()cancella un'istanza della classe, removeAll()rimuove tutti gli oggetti dati e restituisce lo stato dell'operazione.

clear() passerà attraverso l'array sottostante e imposterà ogni voce su null;

removeAll(collection)passerà attraverso ArrayList controllando la raccolta e remove(Object)se esiste.

Immagino che clear()sia molto più veloce quindi rimuovi Tutto perché non sta confrontando, ecc.

La cancellazione è più veloce perché non passa sopra gli elementi da eliminare. Questo metodo può presumere che TUTTI gli elementi possano essere eliminati.

Remove allnon significa necessariamente eliminare tutti gli elementi nell'elenco, solo quelli forniti come parametri DOVREBBERO essere eliminati. Pertanto, è necessario uno sforzo maggiore per mantenere quelli che non devono essere eliminati.

UNA PRECISAZIONE

Con "loop", intendo che non è necessario verificare se l'elemento deve essere mantenuto o meno. Può impostare il riferimento su nullsenza cercare negli elenchi di elementi forniti da eliminare.

ClearÈ più veloce di deleteall.

clear () sarà molto più efficiente. Rimuoverà semplicemente ogni singolo elemento. L'uso di removeAll (arraylist) richiederà molto più lavoro perché controllerà ogni elemento dell'arraylist per vedere se esiste nell'arraylist prima di rimuoverlo.

Array => una volta assegnato lo spazio per una variabile Array in fase di esecuzione, lo spazio allocato non può essere esteso o rimosso.

ArrayList => Questo non è il caso dell'arraylist. ArrayList può crescere e ridursi in fase di esecuzione. Lo spazio allocato può essere ridotto a icona o ingrandito in fase di esecuzione.