¿Cuál es la diferencia entre ArrayList.clear () y ArrayList.removeAll ()?

Suponiendo que arraylistse define como ArrayList<String> arraylist, es arraylist.removeAll(arraylist)equivalente a arraylist.clear()?

Si es así, ¿puedo suponer que el clear()método es más eficiente para vaciar la lista de la matriz?

¿Hay alguna advertencia en el uso en arraylist.removeAll(arraylist)lugar de arraylist.clear()?

El código fuente para clear():

public void clear() {
    modCount++;

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

    size = 0;
}

El código fuente de removeAll()(Como se define en 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() es mucho más rápido ya que no tiene que lidiar con todas esas llamadas a métodos adicionales.

Y como señala Atrey, c.contains(..)aumenta la complejidad temporal de removeAllO (n ² ) en oposición a clearO (n).

La complejidad temporal de ArrayList.clear()es O(n)y deremoveAll es O(n^2).

Entonces sí, ArrayList.cleares mucho más rápido.

El clear()método elimina todos los elementos de un solo ArrayList. Es una operación rápida, ya que solo establece los elementos de la matriz ennull .

El removeAll(Collection)método, que se hereda AbstractCollection, elimina todos los elementos que están en la colección de argumentos de la colección a la que llama el método. Es una operación relativamente lenta, ya que tiene que buscar en una de las colecciones involucradas.

A menos que haya una optimización específica que verifique si el argumento pasado removeAll()es la colección en sí (y dudo mucho que tal optimización esté ahí), será significativamente más lenta que una simple .clear().

Aparte de eso (y al menos igualmente importante): arraylist.removeAll(arraylist)es un código obtuso y confuso. Es una forma muy retrasada de decir "borrar esta colección". ¿Qué ventaja tendría sobre lo muy comprensible arraylist.clear() ?

Sirven para diferentes propósitos. clear()borra una instancia de la clase, removeAll()elimina todos los objetos dados y devuelve el estado de la operación.

clear() pasará por la matriz subyacente y establecerá cada entrada en nulo;

removeAll(collection) pasará por ArrayList buscando la colección y remove(Object) si existe.

Me imagino que clear()es mucho más rápido que eliminar todo porque no se compara, etc.

Clear es más rápido porque no recorre los elementos para eliminar. Este método puede suponer que TODOS los elementos se pueden eliminar.

Remove allno significa necesariamente eliminar todos los elementos de la lista, solo aquellos provistos como parámetros DEBERÍAN eliminarse. Por lo tanto, se requiere más esfuerzo para mantener aquellos que no deben eliminarse.

ACLARACIÓN

Por "bucle", quiero decir que no tiene que verificar si el elemento debe mantenerse o no. Puede establecer la referencia anull sin buscar en las listas de elementos proporcionadas para eliminar.

ClearES más rápido que deleteall.

clear () será mucho más eficiente. Simplemente eliminará todos y cada uno de los elementos. El uso de removeAll (arraylist) requerirá mucho más trabajo porque verificará todos los elementos de arraylist para ver si existe en arraylist antes de eliminarlo.

Array => una vez que se asigna el espacio para una variable Array en el tiempo de ejecución, el espacio asignado no se puede extender ni eliminar.

ArrayList => Este no es el caso en arraylist. ArrayList puede crecer y reducirse en el tiempo de ejecución. El espacio asignado se puede minimizar o maximizar en el tiempo de ejecución.