Java 8では、メソッド参照を使用してストリームをフィルタリングできます。次に例を示します。

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

既存のものを否定するメソッド参照を作成する方法はありますか？

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

not以下のようなメソッドを作成することはできましたが、JDKが同様のものを提供しているかどうか疑問に思いました。

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

Predicate.not( … )

java-11新しいメソッドPredicate＃notを提供します

したがって、メソッド参照を無効にすることができます。

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

メソッド参照をインラインで使用できるように、次の静的インポートを計画しています。

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

例えば

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

更新：Java-11以降、JDKには同様のソリューションが組み込まれています。

現在のメソッド参照とは逆のメソッド参照を作成する方法があります。メソッド参照をaに明示的にキャストPredicateし、negate関数を使用して変換する方法を示す、以下の@vlasecの回答を参照してください。それは、他のいくつかのそれほど面倒ではない方法の1つです。

これの反対：

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

これは：

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

またはこれ：

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

個人it -> !it.isEmpty()的には、長い冗長な明示的キャストよりも読みやすく、否定する方が明確なので、後者の手法を好みます。

述語を作成して再利用することもできます。

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

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

または、コレクションまたは配列がある場合は、単純で、オーバーヘッドが少なく、***高速である可能性があるforループを使用します。

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

*より高速なものを知りたい場合は、JMH http://openjdk.java.net/projects/code-tools/jmhを使用し、すべてのJVM最適化を回避しない限り、手動のベンチマークコードを回避します。Java8 ：ストリームのパフォーマンスを参照してください。vsコレクション

** forループテクニックの方が速いことを示唆したことで、私は不安定になっています。これは、ストリームの作成を排除し、別のメソッド呼び出し（述語の負の関数）の使用を排除し、一時的なアキュムレーターリスト/カウンターを排除します。したがって、最後の構成によって保存されるいくつかのことは、それをより速くする可能性があります。

私はそれがより速くなくても、よりシンプルでより良いと思います。ハンマーと釘が必要な場合は、チェーンソーと接着剤を持ち込まないでください。あなた方の何人かがそれに問題を抱えているのを知っています

ウィッシュリスト：StreamJavaユーザーがJava 関数に慣れてきているため、Java 関数が少し進化することを期待しています。たとえば、Streamの「count」メソッドはaを受け入れるPredicateことができるため、これは次のように直接実行できます。

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

or

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

Predicateメソッドを持っているand、orとnegate。

ただし、String::isEmptyはではなく、Predicate単なるString -> Booleanラムダであり、それでも何かになる可能性がありFunction<String, Boolean>ます。型推論は、最初に行う必要があることです。filterこの方法の推論を入力し、暗黙的に。しかし、引数として渡す前にそれを否定すると、それは起こりません。@axtavtが言及したように、明示的な推論は醜い方法として使用できます。

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

他の回答でアドバイスされている他の方法があり、静的notメソッドとラムダが最も良いアイデアである可能性が最も高いです。これでtl; drセクションは終わりです。

ただし、ラムダ型の推論について理解を深めたい場合は、例を使用して少し詳しく説明します。これらを見て、何が起こるかを理解してみてください：

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はコンパイルされません-ラムダは機能的なインターフェースを推測する必要があります（= 1つの抽象メソッドで）
• p1とf1は正常に機能し、それぞれ異なるタイプを推測します
• obj2はa PredicateをキャストしますObject-ばかげていますが有効です
• f2は、実行時に失敗した-あなたはキャストすることはできませんPredicateしFunction、それは推論について、もはやません
• f3が機能する- testラムダで定義されている述語のメソッドを呼び出す
• p2はコンパイルされません- メソッドIntegerがありませんisEmpty
• p3もコンパイルしません- 引数をString::isEmpty持つ静的メソッドはありませんInteger

これが、型推論がどのように機能するかについてのさらなる洞察を得るために役立つことを願っています。

他者の答えと個人的な経験に基づいて構築する：

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

別のオプションは、曖昧でないコンテキストでラムダキャストを1つのクラスに利用することです。

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

}

...次に、ユーティリティクラスを静的にインポートします。

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

Predicate#negateあなたが探しているものではありませんか？

この場合、uを使用しorg.apache.commons.lang3.StringUtilsて行うことができます

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

Java 8ラムダ式を取得して（該当する場合）パッケージで定義された型付き標準Java 8ラムダに変換できる完全なユーティリティクラス（Askarの提案に触発された）を作成しましたjava.util.function。たとえば、次のことができます。

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

すべての静的メソッドにjustという名前as()を付けると多くのあいまいさが生じるため、メソッドとして「as」を呼び出し、その後に返された型を呼び出すことを選択しました。これにより、ラムダ解釈を完全に制御できます。以下は、使用されているパターンを明らかにする（やや大きい）ユーティリティクラスの最初の部分です。

見ていここに完全なクラスを（要旨で）。

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

あなたは使用することができ述語からEclipseのコレクション

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

から文字列を変更できない場合List：

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

否定のみ必要なString.isEmpty()場合は、も使用できますStringPredicates.notEmpty()。

注：私はEclipseコレクションの寄稿者です。

あなたはこれを長く続けることができます emptyStrings = s.filter(s->!s.isEmpty()).count();

Spring Boot（2.0.0+）を使用している場合は、以下を使用できます。

import org.springframework.util.StringUtils;

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

どれが： return (str != null && !str.isEmpty());

だからそれは必要な否定効果を持っています isEmpty