Wie negieren eine Methode, Referenz-Prädikat

Plane ich, mit dem statischen import die folgenden zu ermöglichen, die für die Methode Referenz benutzt inline:

public static <T> Predicate<T> not(Predicate<T> t) {
    return t.negate();
}

z.B.

Stream<String> s = ...;
long nonEmptyStrings = s.filter(not(String::isEmpty)).count();

Update:- Gut das JDK/11 möglicherweise mit einem ähnliche Lösung, als gut.

InformationsquelleAutor davidillsley

Predicate Methoden and, or und negate.

Jedoch String::isEmpty ist nicht ein Predicate, es ist nur ein String -> Boolean lambda und könnte es immer noch etwas, z.B. Function<String, Boolean>. Typ-Inferenz ist, was geschehen muss, ersten. Die filter Methode folgert Typ implizit. Aber wenn Sie negieren, es vor der übergabe als argument, es nicht mehr passiert. @Axtavt erwähnt, explizite Inferenz verwendet werden kann, als eine hässliche Art und Weise:

s.filter(((Predicate<String>) String::isEmpty).negate()).count()

Gibt es andere Möglichkeiten hingewiesen, die in anderen Antworten, mit statischen not Methode und lambda-wahrscheinlich die besten Ideen. Dies schließt die tl;dr Abschnitt.

Jedoch, wenn Sie möchten, einige tiefere Verständnis von lambda-Typ-Inferenz, würde ich mag, um zu erklären, es ein bisschen mehr Tiefe, mit Beispielen. Diese anschauen und versuchen, herauszufinden, was passiert:

Object obj1                  = String::isEmpty;
Predicate<String> p1         = s -> s.isEmpty();
Function<String, Boolean> f1 = String::isEmpty;
Object obj2                  = p1;
Function<String, Boolean> f2 = (Function<String, Boolean>) obj2;
Function<String, Boolean> f3 = p1::test;
Predicate<Integer> p2        = s -> s.isEmpty();
Predicate<Integer> p3        = String::isEmpty;

• obj1 nicht kompilieren - Lambda-Ausdrücke ableiten müssen eine funktionale Schnittstelle (= mit einer abstrakten Methode)
• p1 und der f1 nur gut funktionieren, jede Herleitung von einer anderen Art
• obj2 wirft einen Predicate zu Object - dumm aber gültig
• f2 scheitert zur Laufzeit - Sie können nicht gegossen Predicate zu Function es nicht mehr um die Ableitung
• f3 funktioniert - Sie nennen das Prädikat Methode test definiert ist durch seine lambda
• p2 nicht kompilieren - Integer nicht isEmpty Methode
• p3 kann nicht kompiliert werden, entweder - es gibt keine String::isEmpty statische Methode mit Integer argument

Ich hoffe, das hilft ein bißchen mehr Einblick in die Art, wie inferrence funktioniert.

InformationsquelleAutor Vlasec

Weitere option ist die Verwendung von lambda-casting in nicht-mehrdeutige Kontexte, in einer Klasse:

public static class Lambdas {
    public static <T> Predicate<T> as(Predicate<T> predicate){
        return predicate;
    }

    public static <T> Consumer<T> as(Consumer<T> consumer){
        return consumer;
    }

    public static <T> Supplier<T> as(Supplier<T> supplier){
        return supplier;
    }

    public static <T, R> Function<T, R> as(Function<T, R> function){
        return function;
    }

}

... und dann statisch importieren Sie die utility-Klasse:

stream.filter(as(String::isEmpty).negate())

InformationsquelleAutor Askar Kalykov

In diesem Fall u könnte die org.apache.commons.lang3.StringUtilsund tun

int nonEmptyStrings = s.filter(StringUtils::isNotEmpty).count();

InformationsquelleAutor outofBounds

Ich geschrieben habe, eine komplette utility-Klasse, die (inspiriert durch Suleiman den Vorschlag), der kann Java 8 lambda-Ausdruck, und schalten Sie Sie (falls zutreffend) in einen beliebigen typisierten standard-Java 8-lambda definiert im Paket java.util.function. Können Sie zum Beispiel tun:

• asPredicate(String::isEmpty).negate()
• asBiPredicate(String::equals).negate()

Da es zahlreiche Unklarheiten, wenn alle statischen Methoden würde den Namen nur as(), entschied ich mich Sie zum aufrufen der Methode "as" gefolgt von dem zurückgegebenen Typ. Dies gibt uns volle Kontrolle über die lambda-interpretation. Unten ist der erste Teil der (etwas große) utility-Klasse enthüllt die Muster verwendet.

Haben Sie einen Blick auf die komplette Klasse hier (bei gist).

public class FunctionCastUtil {

    public static <T, U> BiConsumer<T, U> asBiConsumer(BiConsumer<T, U> biConsumer) {
        return biConsumer;
    }

    public static <T, U, R> BiFunction<T, U, R> asBiFunction(BiFunction<T, U, R> biFunction) {
        return biFunction;
    }

     public static <T> BinaryOperator<T> asBinaryOperator(BinaryOperator<T> binaryOperator) {
        return binaryOperator;
    }

    ... and so on...
}

InformationsquelleAutor Per-Åke Minborg

Können Sie dies erreichen, so lange emptyStrings = s.filter(s->!s.isEmpty()).count();

InformationsquelleAutor Narsi Reddy Nallamilli