Apakah mungkin untuk melakukan Stream di Java 8?

Apakah mungkin untuk melakukan streaming di Java 8? Katakanlah saya memiliki daftar objek, saya dapat melakukan sesuatu seperti ini untuk menyaring semua objek tambahan:

Stream.of(objects).filter(c -> c instanceof Client)

Namun setelah ini, jika saya ingin melakukan sesuatu dengan klien saya akan perlu masing-masing:

Stream.of(objects).filter(c -> c instanceof Client)
    .map(c -> ((Client) c).getID()).forEach(System.out::println);

Ini terlihat agak jelek. Apakah mungkin untuk mengalirkan seluruh aliran ke jenis yang berbeda? Seperti dilemparkan Stream<Object>ke Stream<Client>?

Abaikan fakta bahwa melakukan hal-hal seperti ini mungkin akan berarti desain yang buruk. Kami melakukan hal-hal seperti ini di kelas ilmu komputer saya, jadi saya mencari fitur-fitur baru java 8 dan ingin tahu apakah ini mungkin.

Saya tidak berpikir ada cara untuk melakukan itu di luar kotak. Solusi yang mungkin lebih bersih adalah:

Stream.of(objects)
    .filter(c -> c instanceof Client)
    .map(c -> (Client) c)
    .map(Client::getID)
    .forEach(System.out::println);

atau, seperti yang disarankan dalam komentar, Anda dapat menggunakan castmetode ini - yang pertama mungkin lebih mudah dibaca:

Stream.of(objects)
    .filter(Client.class::isInstance)
    .map(Client.class::cast)
    .map(Client::getID)
    .forEach(System.out::println);

Sejalan dengan jawaban ggovan , saya melakukan ini sebagai berikut:

/**
 * Provides various high-order functions.
 */
public final class F {
    /**
     * When the returned {@code Function} is passed as an argument to
     * {@link Stream#flatMap}, the result is a stream of instances of
     * {@code cls}.
     */
    public static <E> Function<Object, Stream<E>> instancesOf(Class<E> cls) {
        return o -> cls.isInstance(o)
                ? Stream.of(cls.cast(o))
                : Stream.empty();
    }
}

Menggunakan fungsi pembantu ini:

Stream.of(objects).flatMap(F.instancesOf(Client.class))
        .map(Client::getId)
        .forEach(System.out::println);

Terlambat ke pesta, tapi kupikir itu jawaban yang berguna.

flatMap akan menjadi cara terpendek untuk melakukannya.

Stream.of(objects).flatMap(o->(o instanceof Client)?Stream.of((Client)o):Stream.empty())

Jika oa Clientmaka buat Stream dengan elemen tunggal, jika tidak gunakan aliran kosong. Aliran ini kemudian akan diratakan menjadi a Stream<Client>.

Ini terlihat agak jelek. Apakah mungkin untuk mengalirkan seluruh aliran ke jenis yang berbeda? Seperti dilemparkan Stream<Object>ke Stream<Client>?

Tidak, itu tidak mungkin. Ini bukan hal baru di Java 8. Ini khusus untuk obat generik. A List<Object>bukan tipe super List<String>, jadi Anda tidak bisa hanya memberikan List<Object>aList<String> .

Serupa adalah masalah di sini. Anda tidak dapat melemparkan Stream<Object>ke Stream<Client>. Tentu saja Anda dapat melemparkannya secara tidak langsung seperti ini:

Stream<Client> intStream = (Stream<Client>) (Stream<?>)stream;

tapi itu tidak aman, dan mungkin gagal saat runtime. Alasan yang mendasari hal ini adalah, obat generik di Jawa diimplementasikan menggunakan erasure. Jadi, tidak ada informasi jenis yang tersedia tentang jenis Streamitu saat runtime. Semuanya adilStream .

BTW, apa yang salah dengan pendekatan Anda? Terlihat baik untuk saya.