Quelle est la différence entre ArrayList.clear () et ArrayList.removeAll ()?

En supposant que cela arraylistsoit défini comme ArrayList<String> arraylist, est arraylist.removeAll(arraylist)équivalent à arraylist.clear()?

Si oui, puis-je supposer que la clear()méthode est plus efficace pour vider la liste des tableaux?

Y a-t-il des mises en garde à utiliser à la arraylist.removeAll(arraylist)place de arraylist.clear()?

Le code source de clear():

public void clear() {
    modCount++;

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

    size = 0;
}

Le code source de removeAll()(tel que défini dans 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() est beaucoup plus rapide car il n'a pas à gérer tous ces appels de méthode supplémentaires.

Et comme le souligne Atrey, c.contains(..)augmente la complexité temporelle de removeAllO (n ² ) par opposition à clearO (n).

La complexité temporelle de ArrayList.clear()est O(n)et de removeAllest O(n^2).

Alors oui, ArrayList.clearc'est beaucoup plus rapide.

La clear()méthode supprime tous les éléments d'un seul ArrayList. C'est une opération rapide, car elle définit simplement les éléments du tableau sur null.

La removeAll(Collection)méthode, héritée de AbstractCollection, supprime tous les éléments qui se trouvent dans la collection d'arguments de la collection sur laquelle vous appelez la méthode. C'est une opération relativement lente, car elle doit rechercher dans l'une des collections impliquées.

À moins qu'il n'y ait une optimisation spécifique qui vérifie si l'argument transmis removeAll()est la collection elle-même (et je doute fortement qu'une telle optimisation soit là), elle sera considérablement plus lente qu'une simple .clear().

En dehors de cela (et au moins tout aussi important): arraylist.removeAll(arraylist)est juste un code obtus et déroutant. C'est une manière très arriérée de dire "effacer cette collection". Quel avantage aurait-il sur le très compréhensible arraylist.clear() ?

Ils servent à des fins différentes. clear()efface une instance de la classe, removeAll()supprime tous les objets donnés et retourne l'état de l'opération.

clear() passera par le tableau sous-jacent et définira chaque entrée sur null;

removeAll(collection)passera par ArrayList en vérifiant la collecte et remove(Object)s'il existe.

J'imagine que clear()c'est beaucoup plus rapide que removeAll car ce n'est pas comparer, etc.

Clear est plus rapide car il ne boucle pas sur les éléments à supprimer. Cette méthode peut supposer que TOUS les éléments peuvent être supprimés.

Remove allne signifie pas nécessairement supprimer tous les éléments de la liste, seuls ceux fournis en tant que paramètres DEVRAIENT être supprimés. Par conséquent, davantage d'efforts sont nécessaires pour conserver ceux qui ne devraient pas être supprimés.

CLARIFICATION

Par «boucle», je veux dire qu'il n'a pas à vérifier si l'élément doit être conservé ou non. Il peut définir la référence nullsans rechercher dans les listes d'éléments à supprimer fournies.

ClearEST plus rapide que deleteall.

clear () sera beaucoup plus efficace. Il supprimera simplement chaque élément. L'utilisation de removeAll (arraylist) demandera beaucoup plus de travail car elle vérifiera chaque élément dans arraylist pour voir s'il existe dans arraylist avant de le supprimer.

Array => une fois que l'espace est alloué pour une variable Array au moment de l'exécution, l'espace alloué ne peut pas être étendu ou supprimé.

ArrayList => Ce n'est pas le cas dans arraylist. ArrayList peut croître et se réduire au moment de l'exécution. L'espace alloué peut être minimisé ou maximisé au moment de l'exécution.