[JAVA] Ich hoffe aufrichtig, dass Stream # abgelehnt wird

Nun, in Wirklichkeit ist es nicht so viel, wie ich wirklich hoffe,

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

Ich möchte so schreiben.

Aber in Wirklichkeit gibt es so etwas nicht ...

Es wird mit Stream # filter geschrieben.

Wenn ich verschiedene Dinge schreibe ...

Gibt die Ablehnung in der zu implementierenden Funktion zurück

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

Nun, eine einfache Implementierung ist nicht schlecht, aber komplizierte Bedingungen können verwirrend werden.

Selbst unter einfachen Bedingungen befürchte ich, dass Sie ! Auf einen Blick verpassen könnten.

Verwenden Sie Prädikat # negieren

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

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

Predicate # negate selbst hat erreicht, was ich wirklich tun möchte, aber die Besetzung ist ...: schreien:

Erstellen Sie eine Methode, die eine negative Bedingung zurückgibt

//Gibt das Prädikat des negativen Zustands des ursprünglichen Zustands zurück
private <E> Predicate<? super E> not(Predicate<? super E> p) {
    return p.negate();
}

So etwas machen

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

Jep! nicht schlecht!

Wenn Sie jedoch "nicht" als Dienstprogramm verwenden, sieht es wie "StreamUtils.not" aus und die Beschreibung ist lang.

Wickeln Sie es ein!

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#Filter einwickeln
    public StreamWrapper<T> filter(Predicate<T> p) {
        return this.of(stream.filter(p));
    }

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

    // ...Viele andere Wraps

    /**
     *Entspricht dem angegebenen Prädikat in den Elementen dieses Streams<b>TU es nicht</b>Gibt einen aus Dingen zusammengesetzten Stream zurück.
     * <p>
     *Dies ist eine Zwischenoperation.
     *
     * @param predicate
     *Ein nicht störendes, zustandsloses Prädikat wird auf jedes Element angewendet, um zu bestimmen, ob es enthalten sein soll
     * @neuen Stream zurückgeben
     */
    public StreamWrapper<T> reject(Predicate<T> predicate) {
        return this.of(stream.filter(predicate.negate()));
    }

}

So etwas machen

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

Du hast es geschafft!

(~~ Nun, es dauert nicht so lange, bis "abgelehnt" wird, aber ... ~~)

Erstellen Sie eine Implementierungsklasse!

~~ JMT (Implementierung / Ernst / Anstrengung: unschuldig :) ~~

Child Stream API, die ziemlich zeitaufwändig ist

Selbst wenn Sie sagen "Ich möchte diese Art von Zwischenoperation!", Ist es schwer zu erweitern.

Java9 hat takeWhile`` dropWhile`` ofNullable hinzugefügt, um es bequemer zu machen, implementiert jedoch keine wichtigen Funktionen wie zip (auch ablehnen). Erweitern Sie es daher nach Bedarf. Wie ist das? : yum: