Vérifier si une liste est vide dans java 8

Je suis nouveau sur Java8. J'ai mis en œuvre des listes et filtres. J'ai fait un null vérifier dans mon code. J'apprécierais un peu d'aide avec la façon de vérifier si la liste n'est pas vide dans le même extrait de code. Si la liste n'est pas vide, alors le code doit procéder à l'affirmation.

    list.stream().filter(listElement -> listElement != null).
    forEach((listElement) -> Assert.assertEquals(
        ValueType.CANDY,
        listElement.getCandyType()));

OriginalL'auteur Drools_user | 2015-12-22

  1. 18

    Vous demandez obsolète question. Flux de processus de tous les éléments d'une source, d'où, si il n'y a pas d'éléments, aucune action ne sera prise. Par conséquent, vous n'avez pas besoin de vérifier si la liste est vide.

    Encore, vous pouvez simplifier votre code:

    list.stream().filter(Objects::nonNull)
    .map(listElement -> listElement.getCandyType())
    .forEach(candyType -> Assert.assertEquals(ValueType.CANDY, candyType));

    ou

    Assert.assertTrue(list.stream().filter(Objects::nonNull)
                      .map(listElement -> listElement.getCandyType())
                      .allMatch(Predicate.isEqual(ValueType.CANDY));

    allMatch suit les règles nécessaires à cette vérification. Si il n'y a pas d'éléments, il n'y a pas de contredire élément, donc tous les match. Notez que listElement -> listElement.getCandyType() peut également être remplacée par une référence à une méthode de la forme ClassName::getCandyType; je ne l'ai pas fait ici car je ne sais pas le bon nom de la classe.

    Il n'y a pas de différence de performances entre les deux variantes. allMatch sera de retour immédiatement lors d'une rencontre avec le premier non-élément correspondant, et assertEquals vont se jeter sur le premier non l'élément correspondant. Dans le second cas, la trace de la pile ne vais pas vous montrer les artefacts du flux à l'implémentation de l'API.

    Le second est préféré lorsque vous fournissez des contrôles pour la production de code plutôt que de tests unitaires et de permettre à son tour de ces vérifications, comme avec le Langage Java assert fonction, par exemple,

    assert list.stream().filter(Objects::nonNull)
           .map(listElement -> listElement.getCandyType())
           .allMatch(Predicate.isEqual(ValueType.CANDY));

    que cette forme garantit qu'il n'y aura pas de surcharge lorsque les assertions sont éteints, alors que la première variante, ayant une assert déclaration auprès de la forEach action peut provoquer une itération sur tous les éléments et en effectuant les étapes intermédiaires de la canalisation.

    L'inconvénient de cette démarche est qu'en cas de défaillance du code original d'affichage, une réelle non-correspondance de la valeur comme "s'attendre à des BONBONS, mais a été: SHMANDY" alors que votre code serait juste de dire que l'échec de l'assertion.
    Valeev: ma première variante encore fait. S'il est discutable de savoir si cette information est vraiment utile. Peut-être l'indice serait plus utile, peut-être le non correspondantes des éléments, si il y a quelques... Généralement, l'histoire qui a conduit à l'erreur de l'etat est ce dont vous avez besoin, mais c'est quelque chose, ni variante peut offrir.
    Merci.J'ai choisi votre réponse.Il a été très clair et amélioré mon code aussi.

    OriginalL'auteur Holger

  2. 12

    La réponse choisie est grande, juste une petite suggestion pour gérer la valeur null cas avec Optional.ofNullable de la nouvellement introduit à Java8 classe Optionnelle:

      Optional.ofNullable(list)
            .orElseGet(Collections::emptyList)
            .stream().filter(Objects::nonNull)
            .map(listElement -> listElement.getCandyType())
            .forEach(candyType -> Assert.assertEquals(ValueType.CANDY, candyType)););

    OriginalL'auteur Stas

  3. 7

    Découvrez la isEmpty méthode

    if (list.isEmpty()) { ... }

    Voici la doc: https://docs.oracle.com/javase/7/docs/api/java/util/List.html#isEmpty()

    Je vous remercie, mais je voulais connaître la syntaxe de la façon dont il a pu être vérifié dans le flux de Java8
    Si la liste est vide, l'assertion n'arrivera pas de toute façon, puisqu'il n'y aura pas tous les éléments pour qu'il boucle sur

    OriginalL'auteur Buddy

  4. 1

    Affirmant que la liste est vide, est une activité à part de faire valoir qu'aucun élément de la liste dispose d'une forme (c'est à dire getCandyType() == ValueType.CANDY). Essayer de relier les deux idées ensemble est tout simplement pas la bonne façon de faire les choses.

    Ce que vous devez faire est d'ajouter une deuxième assertion, que ce soit avant ou après la forEach, qui ne

    assertThat(list.isEmpty(), not(equalTo(Boolean.FALSE)))

    ... ou quelque chose de semblable.

    L'un des points importants sur vide listes, c'est qu'ils peuvent être traités de la même manière que les listes contenant des éléments. C'est pourquoi des choses comme la Classe optionnelle et la Null modèle existent. Donc, si vous vous souciez vraiment que la liste est vide, vous vraiment devrait rendre distinct de l'assertion.

    Si ces méthodes d'utilitaire de faire ce que leur nom l'indique, not(equalTo(Boolean.FALSE)) est assez obscure façon de dire true...
    Je suppose qu'ils ont aussi capable de message d'erreur de format automatique (quelque chose comme "il n'était pas égale à FALSE"). Si tel niveau de verbosité est absolument inutile ici.
    vous avez raison, la meilleure affirmation serait probablement utiliser la hamcrest IsEmptyCollection.empty() matcher - assertThat(list, not(empty())).

    OriginalL'auteur sisyphus