In Java 8 können Sie eine Methodenreferenz verwenden, um einen Stream zu filtern, zum Beispiel:

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

Gibt es eine Möglichkeit, eine Methodenreferenz zu erstellen, die die Negation einer vorhandenen ist, dh so etwas wie:

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

Ich könnte die notMethode wie unten erstellen , habe mich aber gefragt, ob das JDK etwas Ähnliches anbietet.

static <T> Predicate<T> not(Predicate<T> p) { return o -> !p.test(o); }

Predicate.not( … )

Java-11bietet eine neue Methode Prädikat # nicht

So können Sie die Methodenreferenz negieren:

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

Ich plane, Folgendes statisch zu importieren, damit die Methodenreferenz inline verwendet werden kann:

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 : Ab Java-11 bietet das JDK auch eine ähnliche integrierte Lösung .

Es gibt eine Möglichkeit, eine Methodenreferenz zu erstellen, die das Gegenteil einer aktuellen Methodenreferenz ist. Die Antwort von @ vlasec unten zeigt, wie Sie die Methodenreferenz explizit in a Predicateumwandeln und sie dann mithilfe der negateFunktion konvertieren . Das ist ein Weg unter ein paar anderen, nicht allzu mühsamen Wegen, dies zu tun.

Das Gegenteil davon:

Stream<String> s = ...;
int emptyStrings = s.filter(String::isEmpty).count();

ist das:

Stream<String> s = ...;
int notEmptyStrings = s.filter(((Predicate<String>) String::isEmpty).negate()).count()

oder dieses:

Stream<String> s = ...;
int notEmptyStrings = s.filter( it -> !it.isEmpty() ).count();

Persönlich bevorzuge ich die spätere Technik, weil ich es klarer finde, zu lesen it -> !it.isEmpty()als eine lange ausführliche explizite Besetzung und dann zu negieren.

Man könnte auch ein Prädikat erstellen und es wiederverwenden:

Predicate<String> notEmpty = (String it) -> !it.isEmpty();

Stream<String> s = ...;
int notEmptyStrings = s.filter(notEmpty).count();

Wenn Sie über eine Sammlung oder ein Array verfügen, verwenden Sie einfach eine for-Schleife, die einfach ist, weniger Overhead hat und * möglicherweise ** schneller ist:

int notEmpty = 0;
for(String s : list) if(!s.isEmpty()) notEmpty++;

* Wenn Sie wissen möchten, was schneller ist, verwenden Sie JMH http://openjdk.java.net/projects/code-tools/jmh und vermeiden Sie Hand-Benchmark-Code, es sei denn, es vermeidet alle JVM-Optimierungen - siehe Java 8: Leistung von Streams vs Sammlungen

** Ich bekomme Flak, weil ich behaupte, dass die For-Loop-Technik schneller ist. Es eliminiert eine Stream-Erstellung, es eliminiert die Verwendung eines anderen Methodenaufrufs (negative Funktion für Prädikat) und es eliminiert eine temporäre Akkumulatorliste / Zähler. Also ein paar Dinge, die vom letzten Konstrukt gespeichert werden und die es möglicherweise schneller machen.

Ich denke, es ist einfacher und schöner, wenn auch nicht schneller. Wenn der Job einen Hammer und einen Nagel erfordert, bringen Sie keine Kettensäge und keinen Kleber mit! Ich weiß, dass einige von Ihnen Probleme damit haben.

Wunschliste: Ich würde gerne sehen, dass sich die Java- StreamFunktionen etwas weiterentwickeln, da Java-Benutzer mit ihnen besser vertraut sind. Zum Beispiel könnte die 'count'-Methode in Stream a akzeptieren, Predicateso dass dies direkt wie folgt erfolgen kann:

Stream<String> s = ...;
int notEmptyStrings = s.count(it -> !it.isEmpty());

or

List<String> list = ...;
int notEmptyStrings = lists.count(it -> !it.isEmpty());

Predicatehat Methoden and, orund negate.

Ist String::isEmptyjedoch kein Predicate, es ist nur ein String -> BooleanLambda und es könnte immer noch alles werden, z Function<String, Boolean>. Typinferenz ist das, was zuerst passieren muss. Die filterMethode leitet den Typ implizit ab . Wenn Sie es jedoch negieren, bevor Sie es als Argument übergeben, geschieht dies nicht mehr. Wie @axtavt erwähnte, kann explizite Folgerung als hässlicher Weg verwendet werden:

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

In anderen Antworten werden andere Möglichkeiten empfohlen, wobei statische notMethode und Lambda höchstwahrscheinlich die besten Ideen sind. Dies schließt die tl; dr Abschnitt.

Wenn Sie jedoch ein tieferes Verständnis der Inferenz vom Lambda-Typ wünschen, möchte ich dies anhand von Beispielen etwas ausführlicher erläutern. Schauen Sie sich diese an und versuchen Sie 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 kompiliert nicht - Lambdas müssen auf eine funktionale Schnittstelle schließen (= mit einer abstrakten Methode)
• p1 und f1 funktionieren einwandfrei und schließen jeweils auf einen anderen Typ ab
• obj2 wirft ein Predicatezu Objectdummes, aber gültiges
• f2 nicht zur Laufzeit - man kann nicht werfen Predicatezu Function, es geht nicht mehr um Inferenz
• f3 funktioniert - Sie rufen die Methode des Prädikats auf test, die durch sein Lambda definiert ist
• p2 kompiliert nicht - Integerhat keine isEmptyMethode
• p3 wird auch nicht kompiliert - es gibt keine String::isEmptystatische Methode mit IntegerArgument

Ich hoffe, dies hilft, mehr Einblick in die Funktionsweise der Typinferenz zu bekommen.

Aufbauend auf den Antworten und persönlichen Erfahrungen anderer:

Predicate<String> blank = String::isEmpty;
content.stream()
       .filter(blank.negate())

Eine andere Möglichkeit besteht darin, Lambda-Casting in nicht mehrdeutigen Kontexten in einer Klasse zu verwenden:

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 die Utility-Klasse importieren:

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

Sollte nicht das Predicate#negatesein, wonach Sie suchen?

In diesem Fall könnten Sie das org.apache.commons.lang3.StringUtilsund tun

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

Ich habe eine vollständige Utility-Klasse geschrieben (inspiriert von Askars Vorschlag), die Java 8-Lambda-Ausdrücke verwenden und sie (falls zutreffend) in jedes im Paket definierte typisierte Standard-Java 8-Lambda umwandeln kann java.util.function. Sie können zum Beispiel Folgendes tun:

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

Da es zahlreiche Unklarheiten geben würde, wenn alle statischen Methoden nur benannt würden as(), habe ich mich dafür entschieden, die Methode "as" gefolgt vom zurückgegebenen Typ aufzurufen. Dies gibt uns die volle Kontrolle über die Lambda-Interpretation. Unten ist der erste Teil der (etwas großen) Utility-Klasse, der das verwendete Muster enthüllt.

Schauen Sie sich hier die gesamte Klasse an (im Kern).

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...
}

Sie können Prädikate aus Eclipse-Sammlungen verwenden

MutableList<String> strings = Lists.mutable.empty();
int nonEmptyStrings = strings.count(Predicates.not(String::isEmpty));

Wenn Sie die Zeichenfolgen nicht ändern können von List:

List<String> strings = new ArrayList<>();
int nonEmptyStrings = ListAdapter.adapt(strings).count(Predicates.not(String::isEmpty));

Wenn Sie nur eine Negation von benötigen String.isEmpty(), können Sie auch verwenden StringPredicates.notEmpty().

Hinweis: Ich bin ein Mitarbeiter von Eclipse Collections.

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

Wenn Sie Spring Boot (2.0.0+) verwenden, können Sie Folgendes verwenden:

import org.springframework.util.StringUtils;

...
.filter(StringUtils::hasLength)
...

Welches tut: return (str != null && !str.isEmpty());

Es wird also den erforderlichen Negationseffekt für haben isEmpty