Comment supprimer tous les éléments nuls d'un ArrayList ou d'un String Array?

J'essaye avec une boucle comme ça

// ArrayList tourists

for (Tourist t : tourists) {
    if (t != null) {     
        t.setId(idForm); 
    }   
}

Mais ce n'est pas sympa. Quelqu'un peut-il me suggérer une meilleure solution?

Quelques repères utiles pour prendre une meilleure décision:

Tandis que la boucle, pour la boucle et le test de performance d'itérateur

Essayer:

tourists.removeAll(Collections.singleton(null));

Lisez l' API Java . Le code lancera java.lang.UnsupportedOperationExceptionpour les listes immuables (telles que créées avec Arrays.asList); voir cette réponse pour plus de détails.

À partir de 2015, c'est le meilleur moyen (Java 8):

tourists.removeIf(Objects::isNull);

Remarque: Ce code sera lancé java.lang.UnsupportedOperationExceptionpour les listes de taille fixe (telles que créées avec Arrays.asList), y compris les listes immuables.

list.removeAll(Collections.singleton(null));

Il sera Lancers UnsupportedException si vous l' utilisez sur Arrays.asList car il vous donne Immuable copie ne peut donc pas être modifié. Voir ci-dessous le code. Il crée une copie Mutable et ne lèvera aucune exception.

public static String[] clean(final String[] v) {
    List<String> list = new ArrayList<String>(Arrays.asList(v));
    list.removeAll(Collections.singleton(null));
    return list.toArray(new String[list.size()]);
}

Pas efficace, mais court

while(tourists.remove(null));

Si vous préférez des objets de données immuables, ou si vous ne voulez tout simplement pas être destructeur pour la liste d'entrée, vous pouvez utiliser les prédicats de Guava.

ImmutableList.copyOf(Iterables.filter(tourists, Predicates.notNull()))

 for (Iterator<Tourist> itr = tourists.iterator(); itr.hasNext();) {
      if (itr.next() == null) { itr.remove(); }
 }

Avant Java 8, vous devez utiliser:

tourists.removeAll(Collections.singleton(null));

Utilisation post-Java 8:

tourists.removeIf(Objects::isNull);

La raison ici est la complexité du temps. Le problème avec les tableaux est qu'une opération de suppression peut prendre du temps O (n). En réalité, en Java, il s'agit d'une copie de tableau des éléments restants déplacés pour remplacer l'emplacement vide. De nombreuses autres solutions proposées ici déclencheront ce problème. Le premier est techniquement O (n * m) où m vaut 1 car c'est un singleton nul: donc O (n)

Vous devriez removeAll du singleton, en interne, il fait un batchRemove () qui a une position de lecture et une position d'écriture. Et répète la liste. Lorsqu'il atteint une valeur nulle, il itère simplement la position de lecture de 1. Quand ils sont identiques, il passe, quand ils sont différents, il continue à copier les valeurs. Puis à la fin, il s'adapte à la taille.

Il le fait efficacement en interne:

public static <E> void removeNulls(ArrayList<E> list) {
    int size = list.size();
    int read = 0;
    int write = 0;
    for (; read < size; read++) {
        E element = list.get(read);
        if (element == null) continue;
        if (read != write) list.set(write, element);
        write++;
    }
    if (write != size) {
        list.subList(write, size).clear();
    }
}

Ce que vous pouvez voir explicitement est une opération O (n).

La seule chose qui pourrait jamais être plus rapide est si vous avez itéré la liste des deux extrémités, et lorsque vous avez trouvé un null, vous définissez sa valeur égale à la valeur que vous avez trouvée à la fin et décrémentez cette valeur. Et itéré jusqu'à ce que les deux valeurs correspondent. Vous gâcheriez l'ordre, mais réduiriez considérablement le nombre de valeurs que vous définissez par rapport à celles que vous avez laissées seules. Ce qui est une bonne méthode à connaître mais qui n'aidera pas beaucoup ici car .set () est fondamentalement gratuit, mais cette forme de suppression est un outil utile pour votre ceinture.

for (Iterator<Tourist> itr = tourists.iterator(); itr.hasNext();) {
      if (itr.next() == null) { itr.remove(); }
 }

Bien que cela semble assez raisonnable, le .remove () sur l'itérateur appelle en interne:

ArrayList.this.remove(lastRet);

Ce qui est encore l'opération O (n) dans l'enlèvement. Il fait un System.arraycopy () qui n'est pas non plus ce que vous voulez, si vous vous souciez de la vitesse. Cela en fait n ^ 2.

Il y a aussi:

while(tourists.remove(null));

Qui est O (m * n ^ 2). Ici, nous ne faisons pas qu'itérer la liste. Nous réitérons la liste entière, chaque fois que nous correspondons à la valeur nulle. Ensuite, nous effectuons n / 2 (moyennes) opérations pour faire le System.arraycopy () pour effectuer la suppression. Vous pouvez littéralement trier toute la collection entre les éléments avec des valeurs et les éléments avec des valeurs nulles et couper la fin en moins de temps. En fait, c'est vrai pour tous les cassés. Au moins en théorie, le system.arraycopy réel n'est pas réellement une opération N en pratique. En théorie, théorie et pratique sont la même chose; en pratique, ils ne le sont pas.

Il existe un moyen simple de supprimer toutes les nullvaleurs de collection.Vous devez passer une collection contenant null comme paramètre à la removeAll()méthode

List s1=new ArrayList();
s1.add(null);

yourCollection.removeAll(s1);

La Objectsclasse a un nonNull Predicatequi peut être utilisé avec filter.

Par exemple:

tourists.stream().filter(Objects::nonNull).collect(Collectors.toList());

En utilisant Java 8, vous pouvez le faire en utilisant stream()etfilter()

tourists = tourists.stream().filter(t -> t != null).collect(Collectors.toList())

ou

tourists = tourists.stream().filter(Objects::nonNull).collect(Collectors.toList())

Pour plus d'informations: Java 8 - Streams

C'est un moyen facile de supprimer les valeurs nulles par défaut de l'arraylist

     tourists.removeAll(Arrays.asList(null));  

sinon, la valeur de chaîne "null" est supprimée de l'arraylist

       tourists.removeAll(Arrays.asList("null"));  

J'ai joué avec cela et j'ai découvert que trimToSize () semble fonctionner. Je travaille sur la plate-forme Android donc ça pourrait être différent.

Nous pouvons utiliser l'itérateur pour le même pour supprimer toutes les valeurs nulles.

Iterator<Tourist> itr= tourists.iterator();
while(itr.hasNext()){
    if(itr.next() == null){
        itr.remove();
    }
}

J'ai utilisé l'interface de flux avec l'opération de collecte de flux et une méthode d'assistance pour générer une nouvelle liste.

tourists.stream().filter(this::isNotNull).collect(Collectors.toList());

private <T> boolean isNotNull(final T item) {
    return  item != null;
}

J'utilise principalement ceci:

list.removeAll(Collections.singleton(null));

Mais après avoir appris Java 8, je suis passé à ceci:

List.removeIf(Objects::isNull);

En utilisant Java 8, cela peut être effectué de différentes manières en utilisant des flux, des flux parallèles et une removeIfméthode:

List<String> stringList = new ArrayList<>(Arrays.asList(null, "A", "B", null, "C", null));
List<String> listWithoutNulls1 = stringList.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList()); //[A,B,C]
List<String> listWithoutNulls2 = stringList.parallelStream()
                .filter(Objects::nonNull)
                .collect(Collectors.toList()); //[A,B,C]
stringList.removeIf(Objects::isNull); //[A,B,C]

Le flux parallèle utilisera les processeurs disponibles et accélérera le processus pour des listes de taille raisonnable. Il est toujours conseillé d'effectuer un benchmark avant d'utiliser les flux.

Similaire à la réponse @Lithium, mais ne renvoie pas d'erreur "La liste peut ne pas contenir de type null":

   list.removeAll(Collections.<T>singleton(null));

List<String> colors = new ArrayList<>(
Arrays.asList("RED", null, "BLUE", null, "GREEN"));
// using removeIf() + Objects.isNull()
colors.removeIf(Objects::isNull);