J'étudie la POO et je suis tombé sur des listes de tableaux. J'aimerais savoir comment fonctionne réellement la fonction remove () et quelle est la manière la plus efficace de l'utiliser.
Première méthode pour supprimer tous les "BB"
run: Original ArrayList : [AA, BB, AA, AA, AA, BB] 2 Modified ArrayList : [AA, AA, AA, AA] BUILD SUCCESSFUL (total time: 0 seconds)
3 Réponses :
Si vous utilisez Java8, tout ce dont vous avez besoin est simplement:
aList.removeIf("B"::equals);
Ou en tant que raccourci:
aList.removeIf(s -> s.equals("BB"));
Si vous notez , de cette façon pas besoin de vérifier si l'élément existe ou non dans la liste.
comme une bonne pratique:
Alist
, utilisez plutôt aList
par exemple Le moyen le plus efficace de supprimer d'une arraylist est probablement:
while (Alist.remove("BB")) {}
ou
Alist.removeIf("BB"::equals)
Ces méthodes peuvent être plus efficaces qu'une appelle à remove
car la suppression réelle peut être différée jusqu'à ce que tous les éléments égaux à "BB"
aient été identifiés.
Ceci est important car la suppression d'un élément à partir d'un ArrayList
décale tous les éléments avec un index plus grand "vers le bas de un". Dans le pire des cas (lorsque tous les éléments de liste sont égaux à ce que vous voulez supprimer), les appels de suppression de liste individuelle seraient quadratiques en nombre d'éléments de liste; removeAll
ou removeIf
serait linéaire, car ils peuvent décaler les éléments non supprimés une seule fois, et ne pas se soucier du tout de déplacer les éléments à supprimer. p >
L'inefficacité la plus évidente de la première méthode est que vous appelez remove
autant de fois qu'il y a d'éléments de liste, quel que soit le nombre de fois que l'élément apparaît dans la liste. Dans un exemple particulièrement pathologique, vous pourriez avoir 1M d'éléments dans la liste, où aucun d'entre eux n'est égal à "BB"
: vous appelleriez toujours remove
1M fois.
L'inefficacité la plus évidente de la deuxième méthode est que vous invoquez contains
puis remove
. Vous recherchez l'élément deux fois en faisant cela.
Une méthode plus efficace - mais toujours moins efficace que les deux méthodes au début de cette réponse - serait d'utiliser la valeur de retour de remove code>
, qui est un booléen indiquant si un élément a été effectivement supprimé. Une fois que remove
renvoie false
, il ne sert à rien d'appeler à nouveau remove
, car l'élément est introuvable:
Alist.removeAll(Collections.singleton("BB"))
List<String> list1=new ArrayList(Arrays.asList("AA","BB","AA","AA","AA","BB")); List<String> list2=new ArrayList(); list2=list1.stream().filter(a -> !a.equals("BB")).collect(Collectors.toList()); System.out.println(list2); This works fine !Check it out.
Comment écrire un micro-benchmark correct en Java?
Comment avez-vous déterminé quel extrait de code était le plus efficace?
En fait, je ne l'ai pas fait, et c'est exactement ce que j'essaie de demander .. @Eran