Bagaimana cara memeriksa apakah Java 8 Stream kosong?

Bagaimana cara memeriksa apakah a Streamkosong dan mengeluarkan pengecualian jika tidak, sebagai operasi non-terminal?

Pada dasarnya, saya mencari sesuatu yang setara dengan kode di bawah ini, tetapi tanpa mewujudkan aliran di antaranya. Secara khusus, pemeriksaan tidak boleh dilakukan sebelum aliran benar-benar dikonsumsi oleh operasi terminal.

public Stream<Thing> getFilteredThings() {
    Stream<Thing> stream = getThings().stream()
                .filter(Thing::isFoo)
                .filter(Thing::isBar);
    return nonEmptyStream(stream, () -> {
        throw new RuntimeException("No foo bar things available")   
    });
}

private static <T> Stream<T> nonEmptyStream(Stream<T> stream, Supplier<T> defaultValue) {
    List<T> list = stream.collect(Collectors.toList());
    if (list.isEmpty()) list.add(defaultValue.get());
    return list.stream();
}

Jika Anda dapat hidup dengan kapabilitas paralel terbatas, solusi berikut akan berfungsi:

private static <T> Stream<T> nonEmptyStream(
    Stream<T> stream, Supplier<RuntimeException> e) {

    Spliterator<T> it=stream.spliterator();
    return StreamSupport.stream(new Spliterator<T>() {
        boolean seen;
        public boolean tryAdvance(Consumer<? super T> action) {
            boolean r=it.tryAdvance(action);
            if(!seen && !r) throw e.get();
            seen=true;
            return r;
        }
        public Spliterator<T> trySplit() { return null; }
        public long estimateSize() { return it.estimateSize(); }
        public int characteristics() { return it.characteristics(); }
    }, false);
}

Berikut beberapa contoh kode yang menggunakannya:

List<String> l=Arrays.asList("hello", "world");
nonEmptyStream(l.stream(), ()->new RuntimeException("No strings available"))
  .forEach(System.out::println);
nonEmptyStream(l.stream().filter(s->s.startsWith("x")),
               ()->new RuntimeException("No strings available"))
  .forEach(System.out::println);

Masalah dengan eksekusi paralel (efisien) adalah bahwa mendukung pemisahan Spliteratormemerlukan cara yang aman untuk thread untuk mengetahui apakah salah satu fragmen telah melihat nilai dengan cara yang aman untuk thread. Kemudian fragmen terakhir yang dieksekusi tryAdvanceharus menyadari bahwa itu adalah yang terakhir (dan juga tidak bisa maju) untuk mengeluarkan pengecualian yang sesuai. Jadi saya tidak menambahkan dukungan untuk pemisahan di sini.

Jawaban dan komentar lain benar karena untuk memeriksa konten aliran, seseorang harus menambahkan operasi terminal, dengan demikian "menghabiskan" aliran. Namun, seseorang dapat melakukan ini dan mengubah hasilnya kembali menjadi aliran, tanpa menyangga seluruh konten aliran. Berikut ini beberapa contoh:

static <T> Stream<T> throwIfEmpty(Stream<T> stream) {
    Iterator<T> iterator = stream.iterator();
    if (iterator.hasNext()) {
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
    } else {
        throw new NoSuchElementException("empty stream");
    }
}

static <T> Stream<T> defaultIfEmpty(Stream<T> stream, Supplier<T> supplier) {
    Iterator<T> iterator = stream.iterator();
    if (iterator.hasNext()) {
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);
    } else {
        return Stream.of(supplier.get());
    }
}

Pada dasarnya ubah aliran menjadi an Iteratoruntuk memanggilnya hasNext(), dan jika benar, ubah Iteratorkembali menjadi a Stream. Ini tidak efisien karena semua operasi selanjutnya di aliran akan melalui Iterator hasNext()dannext() metode , yang juga menyiratkan bahwa aliran diproses secara efektif secara berurutan (bahkan jika kemudian berubah paralel). Namun, ini memungkinkan Anda untuk menguji streaming tanpa membuat buffer ke semua elemennya.

Mungkin ada cara untuk melakukan ini menggunakan Spliteratorbukan sebuah Iterator. Hal ini berpotensi memungkinkan aliran yang dikembalikan memiliki karakteristik yang sama dengan aliran masukan, termasuk berjalan secara paralel.

Ini mungkin cukup dalam banyak kasus

stream.findAny().isPresent()

Anda harus melakukan operasi terminal di Arus agar salah satu filter dapat diterapkan. Oleh karena itu Anda tidak dapat mengetahui apakah itu akan kosong sampai Anda mengkonsumsinya.

Hal terbaik yang dapat Anda lakukan adalah menghentikan Stream dengan file findAny() operasi terminal, yang akan berhenti ketika menemukan elemen apa pun, tetapi jika tidak ada, ia harus mengulang semua daftar input untuk mengetahuinya.

Ini hanya akan membantu Anda jika daftar input memiliki banyak elemen, dan salah satu dari beberapa yang pertama melewati filter, karena hanya sebagian kecil dari daftar yang harus dipakai sebelum Anda mengetahui Stream tidak kosong.

Tentu saja Anda masih harus membuat Stream baru untuk menghasilkan daftar output.

Saya pikir harus cukup untuk memetakan boolean

Dalam kode ini adalah:

boolean isEmpty = anyCollection.stream()
    .filter(p -> someFilter(p)) // Add my filter
    .map(p -> Boolean.TRUE) // For each element after filter, map to a TRUE
    .findAny() // Get any TRUE
    .orElse(Boolean.FALSE); // If there is no match return false

Mengikuti ide Stuart, ini bisa dilakukan dengan cara Spliteratorseperti ini:

static <T> Stream<T> defaultIfEmpty(Stream<T> stream, Stream<T> defaultStream) {
    final Spliterator<T> spliterator = stream.spliterator();
    final AtomicReference<T> reference = new AtomicReference<>();
    if (spliterator.tryAdvance(reference::set)) {
        return Stream.concat(Stream.of(reference.get()), StreamSupport.stream(spliterator, stream.isParallel()));
    } else {
        return defaultStream;
    }
}

Saya pikir ini berfungsi dengan Stream paralel karena stream.spliterator()operasi akan menghentikan streaming, dan kemudian membangunnya kembali sesuai kebutuhan

Dalam kasus penggunaan saya, saya membutuhkan default Streamdaripada nilai default. itu cukup mudah untuk diubah jika bukan ini yang Anda butuhkan

Saya hanya akan menggunakan:

stream.count()>0