Quelle est la différence entre ArrayList.clear () et ArrayList.removeAll()?
En Supposant que arraylist est défini comme ArrayList<String> arraylist, est arraylist.removeAll(arraylist) équivalent à arraylist.clear()?
Si c'est le cas, puis-je supposer que la méthode clear() est plus efficace pour vider la liste des tableaux?
Y a-t-il des mises en garde à utiliser arraylist.removeAll(arraylist) au lieu de arraylist.clear()?
9 réponses
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 à traiter tous les appels de méthode.
Et comme le souligne Atrey, c.contains(..) augmente la complexité temporelle de removeAll à O (N^2) par opposition à clear'S O(N).
La complexité du temps de ArrayList.clear() est O(n) et de removeAll est O(n^2).
Donc, oui, ArrayList.clear est beaucoup plus rapide.
Le clear() méthode supprime tous les éléments d'un seul ArrayList. C'est une opération rapide, car elle définit simplement certains éléments de tableau sur null.
La méthode removeAll(Collection), héritée de AbstractCollection, supprime tous les éléments de la collection d'arguments de la collection sur laquelle vous appelez la méthode. C'est une opération relativement lente, car elle doit chercher dans l'une des collections impliquées.
, Sauf s'il existe une optimisation spécifique qui vérifie si l'argument passé à removeAll() est la collection elle-même (et j' hautement doute qu'une telle optimisation est de là), il sera significativement plus lent qu'un simple .clear().
En dehors de cela (et au moins tout aussi important): arraylist.removeAll(arraylist) est juste obtus, le code confus. C'est une façon très rétrograde de dire "effacer cette collection". Quel avantage aurait-il sur le très compréhensible arraylist.clear()?
Ils servent deux buts différents. clear() efface simplement 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 à null;
removeAll(collection) passera par la vérification ArrayList pour la collection et {[2] } si elle existe.
J'imagine que clear() est beaucoup plus rapide que removeAll car il ne compare pas, 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 all ne signifie pas nécessairement supprimer tous les éléments de la liste, seuls ceux fournis en tant que paramètres doivent être supprimés. Il faut donc redoubler d & apos; efforts pour conserver celles qui ne devraient pas être supprimées.
CLARIFICATION
Par 'loop', 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 à null sans chercher dans les listes d'éléments à supprimer fournies.
Clear EST plus rapide que deleteall.
Clear() sera beaucoup plus efficace. Il va simplement supprimer chaque élément. Utiliser removeAll (arraylist) prendra beaucoup plus de travail car il vérifiera chaque élément dans arraylist pour voir s'il existe dans arraylist avant de le supprimer.
Array => une fois l'espace est alloué pour une variable de Tableau au moment de l'exécution, l'espace alloué ne peut être prolongée ou retirée.
ArrayList = > ce n'est pas le cas dans arraylist. ArrayList peut croître et rétrécir au moment de l'exécution. L'espace alloué peut être réduit ou maximisé au moment de l'exécution.