Di Java 8, Anda bisa menggunakan referensi metode untuk memfilter aliran, misalnya:

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

Apakah ada cara untuk membuat referensi metode yang merupakan negasi dari yang sudah ada, yaitu sesuatu seperti:

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

Saya dapat membuat notmetode seperti di bawah ini tetapi saya bertanya-tanya apakah JDK menawarkan sesuatu yang serupa.

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

Predicate.not( … )

java-11menawarkan metode baru. Predikat # tidak

Jadi Anda dapat meniadakan referensi metode:

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

Saya berencana mengimpor statis berikut ini untuk memungkinkan referensi metode yang akan digunakan inline:

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

misalnya

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

Pembaruan : Mulai dari Java-11, JDK juga menawarkan solusi serupa .

Ada cara untuk membuat referensi metode yang merupakan kebalikan dari referensi metode saat ini. Lihat jawaban @ vlasec di bawah ini yang menunjukkan bagaimana dengan secara eksplisit melemparkan referensi metode ke a Predicatedan kemudian mengubahnya menggunakan negatefungsi. Itu adalah salah satu cara di antara beberapa cara lain yang tidak terlalu merepotkan untuk melakukannya.

Kebalikan dari ini:

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

Apakah ini:

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

atau ini:

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

Secara pribadi, saya lebih suka teknik nanti karena saya merasa lebih jelas untuk membaca it -> !it.isEmpty() daripada pemeran verbal panjang dan kemudian meniadakan.

Anda juga bisa membuat predikat dan menggunakannya kembali:

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

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

Atau, jika memiliki koleksi atau array, cukup gunakan for-loop yang sederhana, memiliki lebih sedikit overhead, dan * mungkin ** lebih cepat:

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

* Jika Anda ingin tahu apa yang lebih cepat, maka gunakan JMH http://openjdk.java.net/projects/code-tools/jmh , dan hindari kode benchmark tangan kecuali menghindari semua optimasi JVM - lihat Java 8: kinerja Streams vs Koleksi

** Saya mendapatkan kritik karena menyarankan bahwa teknik for-loop lebih cepat. Ini menghilangkan pembuatan aliran, menghilangkan menggunakan pemanggilan metode lain (fungsi negatif untuk predikat), dan menghilangkan daftar / penghitung akumulator sementara. Jadi beberapa hal yang disimpan oleh konstruk terakhir yang mungkin membuatnya lebih cepat.

Saya pikir itu lebih sederhana dan lebih baik, meskipun tidak lebih cepat. Jika pekerjaan itu membutuhkan palu dan paku, jangan bawa gergaji dan lem! Saya tahu beberapa dari Anda mempermasalahkan hal itu.

wish-list: Saya ingin melihat Streamfungsi Java berkembang sedikit sekarang karena pengguna Java lebih mengenalnya. Misalnya, metode 'hitung' di Stream dapat menerima Predicatesehingga ini dapat dilakukan secara langsung seperti ini:

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

or

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

Predicatememiliki metode and, ordan negate.

Namun, String::isEmptybukan Predicate, itu hanya String -> Booleanlambda dan itu masih bisa menjadi apa saja, misalnya Function<String, Boolean>. Jenis inferensi inilah yang perlu terjadi terlebih dahulu. The filterMetode menyimpulkan ketik secara implisit . Tetapi jika Anda meniadakannya sebelum meneruskannya sebagai argumen, itu tidak lagi terjadi. Seperti @axtavt sebutkan, inferensi eksplisit dapat digunakan sebagai cara yang jelek:

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

Ada cara lain yang disarankan dalam jawaban lain, dengan notmetode statis dan lambda kemungkinan besar menjadi ide terbaik. Ini menyimpulkan bagian dr .

Namun, jika Anda ingin lebih memahami inferensi tipe lambda, saya ingin menjelaskannya sedikit lebih mendalam, menggunakan contoh. Lihat ini dan coba cari tahu apa yang terjadi:

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 tidak dapat dikompilasi - lambdas perlu menyimpulkan antarmuka fungsional (= dengan satu metode abstrak)
• p1 dan f1 berfungsi dengan baik, masing-masing menyimpulkan tipe yang berbeda
• obj2 gips a Predicate keObject - konyol tapi valid
• f2 gagal saat runtime - Anda tidak dapat melakukan cast Predicate keFunction , itu tidak lagi tentang inferensi
• f3 berfungsi - Anda memanggil metode predikat test yang ditentukan oleh lambda-nya
• p2 tidak mengkompilasi - Integer tidak punyaisEmpty metode
• p3 tidak dapat dikompilasi - tidak ada String::isEmptymetode statis denganInteger argumen

Saya harap ini membantu mendapatkan lebih banyak wawasan tentang cara kerja kesimpulan tipe.

Membangun jawaban dan pengalaman pribadi orang lain:

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

Pilihan lain adalah memanfaatkan lambda casting dalam konteks yang tidak ambigu menjadi satu kelas:

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

}

... dan kemudian impor statis kelas utilitas:

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

Bukankah Predicate#negateseharusnya apa yang Anda cari?

Dalam hal ini Anda dapat menggunakan org.apache.commons.lang3.StringUtilsdan melakukannya

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

Saya telah menulis kelas utilitas lengkap (terinspirasi oleh proposal Askar) yang dapat mengambil ekspresi Java 8 lambda dan mengubahnya (jika berlaku) menjadi standar apa pun yang diketikkan Java 8 lambda yang ditentukan dalam paket java.util.function. Misalnya Anda dapat melakukan:

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

Karena akan ada banyak ambiguitas jika semua metode statis akan dinamai adil as() , saya memilih untuk memanggil metode "sebagai" diikuti oleh jenis yang dikembalikan. Ini memberi kita kendali penuh atas interpretasi lambda. Di bawah ini adalah bagian pertama dari kelas utilitas (agak besar) mengungkapkan pola yang digunakan.

Lihatlah kelas lengkapnya di sini (di intisari).

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

Anda dapat menggunakan Predikat dari Eclipse Collections

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

Jika Anda tidak dapat mengubah string dari List:

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

Jika Anda hanya membutuhkan negasi, String.isEmpty()Anda juga dapat menggunakannya StringPredicates.notEmpty().

Catatan: Saya adalah kontributor untuk Eclipse Collections.

Anda bisa melakukannya selama ini emptyStrings = s.filter(s->!s.isEmpty()).count();

Jika Anda menggunakan Spring Boot (2.0.0+) Anda dapat menggunakan:

import org.springframework.util.StringUtils;

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

Yang tidak: return (str != null && !str.isEmpty());

Jadi itu akan memiliki efek negasi yang diperlukan untuk isEmpty