En Java, supprimez les éléments vides d’une liste de chaînes

En Java, j’ai un ArrayList de chaînes comme:

[,Hi, ,How,are,you] 

Je veux supprimer les éléments null et vide, comment le changer pour qu’il soit comme ceci:

 [Hi,How,are,you] 

 List list = new ArrayList(Arrays.asList("", "Hi", null, "How")); System.out.println(list); list.removeAll(Arrays.asList("", null)); System.out.println(list); 

Sortie:

 [, Hi, null, How] [Hi, How] 

C’est une réponse très tardive, mais vous pouvez également utiliser Collections.singleton :

 List list = new ArrayList(Arrays.asList("", "Hi", null, "How")); list.removeAll(Collections.singleton(null)); list.removeAll(Collections.singleton("")); 

Une autre façon de faire cela maintenant que nous avons des expressions Java 8 lambda.

 arrayList.removeIf(item -> item == null || "".equals(item)); 
  1. Si vous demandiez comment supprimer les chaînes vides, vous pouvez le faire comme ceci (où l est un ArrayList ) – cela supprime toutes null références null et les chaînes de longueur 0:

     Iterator i = l.iterator(); while (i.hasNext()) { Ssortingng s = i.next(); if (s == null || s.isEmpty()) { i.remove(); } } 
  2. Ne confondez pas une ArrayList avec des tableaux, une ArrayList est une structure de données dynamic qui redimensionne en fonction de son contenu. Si vous utilisez le code ci-dessus, vous n’avez rien à faire pour obtenir le résultat tel que vous l’avez décrit -si votre ArrayList était [“”, “Hi”, “”, “How”, “are”, ” vous “], après avoir enlevé comme ci-dessus, ce sera exactement ce dont vous avez besoin – ["Hi","How","are","you"] .

    Cependant, si vous devez avoir une copie “assainie” de la liste originale (tout en laissant l’original tel quel) et par “la sauvegarder “, vous vouliez dire ” faire une copie “, alors le code de Krmby dans l’autre réponse vous servira juste bien.

Il y a quelques approches que vous pourriez utiliser:

  1. Parcourez la liste en appelant Iterator.remove() pour les éléments de liste que vous souhaitez supprimer. C’est le plus simple.

  2. Appelez à plusieurs resockets List.remove(Object) . C’est simple aussi, mais c’est pire que tout … parce que vous parsingz à plusieurs resockets la liste entière . (Cependant, cela pourrait être une option pour une liste mutable dont l’iterator ne prenait pas en charge remove … pour une raison quelconque.)

  3. Créez une nouvelle liste, parcourez l’ancienne liste, en ajoutant des éléments que vous souhaitez conserver à une nouvelle liste.

  4. Si vous ne pouvez pas renvoyer la nouvelle liste, comme ci-dessus, puis effacez l’ancienne liste et utilisez addAll pour lui append les éléments de la nouvelle liste.

La méthode la plus rapide dépend de la classe de la liste d’origine, de sa taille et du nombre d’éléments à supprimer. Voici quelques facteurs:

  • Pour une ArrayList , chaque opération de remove individuelle est O(N) , où N est la taille de la liste. Il est coûteux de supprimer plusieurs éléments d’une grande ArrayList en utilisant la méthode Iterator.remove() (ou la méthode ArrayList.remove(element) ).

    En revanche, la méthode Iterator.remove pour une LinkedList est O(1) .

  • Pour une ArrayList , créer et copier une liste est O(N) et relativement bon marché, surtout si vous pouvez vous assurer que la capacité de la liste de destination est suffisamment grande (mais pas trop grande).

    En revanche, la création et la copie sur une LinkedList sont également de type O(N) , mais considérablement plus coûteuses.

Tout cela ajoute à un arbre de décision assez compliqué. Si les listes sont petites (disons 10 éléments ou moins), vous pouvez probablement vous en tirer avec l’une des approches ci-dessus. Si les listes peuvent être volumineuses, vous devez évaluer tous les problèmes dans la liste de la taille de liste attendue et du nombre prévu de suppressions. (Sinon, vous pourriez vous retrouver avec des performances quadratiques.)

  • Ce code comstack et fonctionne correctement.
  • Il n’utilise aucun iterator donc plus lisible.
  • liste est votre collection.
  • Le résultat est un formulaire filtré (pas de null non vide).

 public static void listRemove() { List list = Arrays.asList("", "Hi", "", "How", "are", "you"); List result = new ArrayList(); for (Ssortingng str : list) { if (str != null && !str.isEmpty()) { result.add(str); } } System.out.println(result); } 

Va déposer cette pépite lil ici:

 Stream.of("", "Hi", null, "How", "are", "you") .filter(t -> !Ssortingngs.isNullOrEmpty(t)) .collect(ImmutableList.toImmutableList()); 

Je souhaite de tout mon coeur que Java ait un filterNot .

Si vous obtenez une Arrays.asList() d’utiliser une des réponses ci-dessus et que votre List est créée à partir d’ Arrays.asList() , c’est que vous ne pouvez pas modifier cette List .

Pour corriger, Arrays.asList() dans le new LinkedList() :

  List list = new LinkedList(Arrays.asList(split)); 

La source provient de cette réponse .

En ce qui concerne le commentaire d’Andrew Mairose – Bien que ce soit une bonne solution, je voudrais juste append que cette solution ne fonctionnera pas sur des listes de taille fixe .

Vous pourriez essayer de faire comme ça:

 Arrays.asList(new Ssortingng[]{"a", "b", null, "c", " "}) .removeIf(item -> item == null || "".equals(item)); 

Mais vous rencontrerez une asList UnsupportedOperationException at java.util.AbstractList.remove ( asList une liste non redimensionnable).

Une solution différente pourrait être la suivante:

 List collect = Stream.of(new Ssortingng[]{"a", "b", "c", null, ""}) .filter(item -> item != null && !"".equals(item)) .collect(Collectors.toList()); 

Qui produira une belle liste de chaînes 🙂

  private List cleanInputs(Ssortingng[] inputArray) { List result = new ArrayList(inputArray.length); for (Ssortingng input : inputArray) { if (input != null) { Ssortingng str = input.sortingm(); if (!str.isEmpty()) { result.add(str); } } } return result; } 

Si vous utilisez Java 8, essayez ceci en utilisant l’expression lambda et org.apache.commons.lang.SsortingngUtils , qui effaceront également blank valeurs null et blank de l’entrée du array .

 public static Ssortingng[] cleanArray(Ssortingng[] array) { return Arrays.stream(array).filter(x -> !SsortingngUtils.isBlank(x)).toArray(Ssortingng[]::new); } 

ref – https://stackoverflow.com/a/41935895/9696526