[JAVA] J'espère sincèrement que Stream # rejette

Eh bien, en réalité, ce n'est pas autant que j'espère vraiment,

List.of("a", "", "b").stream()
    .reject(s -> s.isEmpty())
    .collect(Collectors.toList());
// => ["a", "b"]

Je veux écrire comme ça.

Mais en réalité, il n'y a rien de tel ...

Il est écrit en utilisant Stream # filter.

Quand j'écris diverses choses ...

Renvoie le refus dans la fonction à implémenter

List.of("a", "", "b").stream()
    .filter(s -> !s.isEmpty())
    .collect(Collectors.toList());

Eh bien, une implémentation simple n'est pas mauvaise, mais les conditions compliquées peuvent prêter à confusion.

Même dans des conditions simples, j'ai peur que vous manquiez "!" D'un coup d'oeil.

Utiliser Predicate # negate

List.of("a", "", "b").stream()
    .filter(((Predicate<String>) (s -> s.isEmpty())).negate())
    .collect(Collectors.toList());

//Hmmm cast ennuyeux!
Predicate<String> emptyText = s -> s.isEmpty();
List.of("a", "", "b").stream()
    .filter(emptyText.negate())
    .collect(Collectors.toList());

Predicate # negate lui-même a réalisé ce que je veux vraiment faire, mais le casting est ...: scream:

Créer une méthode qui renvoie une condition négative

//Renvoie Prédicat de la condition négative de la condition d'origine
private <E> Predicate<? super E> not(Predicate<? super E> p) {
    return p.negate();
}

Faire quelque chose comme ça

List.of("a", "", "b").stream()
    .filter(not(s -> s.isEmpty()))
    .collect(Collectors.toList());

Ouaip! pas mal!

Cependant, si vous utilisez not comme utilitaire, cela ressemblera à StreamUtils.not et la description sera longue.

Emballe-le!

public class StreamWrapper<T> {

    private final Stream<T> stream;

    // private constructor
    private StreamWrapper(Stream<T> src) {
        this.stream = src;
    }

    // make instance
    public static <T> StreamWrapper<T> of(Stream<T> src) {
        return new StreamWrapper(src);
    }

    // Stream#Filtre enveloppant
    public StreamWrapper<T> filter(Predicate<T> p) {
        return this.of(stream.filter(p));
    }

    // Stream#Envelopper collecter
    public <R, A> R collect(Collector<T, A, R> c) {
        return stream.collect(c);
    }

    // ...Beaucoup d'autres wraps

    /**
     *Correspond au prédicat spécifié dans les éléments de ce flux<b>ne pas faire</b>Renvoie un flux composé de choses.
     * <p>
     *Il s'agit d'une opération intermédiaire.
     *
     * @param predicate
     *Prédicat sans interférence et sans état appliqué à chaque élément pour déterminer s'il doit être inclus
     * @retourner un nouveau flux
     */
    public StreamWrapper<T> reject(Predicate<T> predicate) {
        return this.of(stream.filter(predicate.negate()));
    }

}

Faire quelque chose comme ça

StreamWrapper.of(List.of("a", "", "b").stream())
    .reject(s -> s.isEmpty())
    .collect(Collectors.toList());

Tu l'as fait!

(~~ Eh bien, cela ne prend pas beaucoup de temps pour rejeter, mais ... ~~)

Créez une classe d'implémentation!

~~ JMT (Implémentation / Sérieusement / Effort: innocent :) ~~

API Child Stream qui prend beaucoup de temps

Même si vous dites "je veux ce genre d'opération intermédiaire!", Il est difficile de se développer.

Java9 a ajouté takeWhile`` dropWhile ʻofNullable pour le rendre plus pratique, mais il n'implémente pas de fonctionnalités majeures telles que zip (également rejet`), alors essayez de l'étendre si nécessaire. Comment c'est? : Miam: