È possibile trasmettere un flusso in Java 8?

È possibile trasmettere un flusso in Java 8? Supponiamo di avere un elenco di oggetti, posso fare qualcosa del genere per filtrare tutti gli oggetti aggiuntivi:

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

Dopo questo però, se voglio fare qualcosa con i clienti, dovrei lanciare ciascuno di essi:

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

Sembra un po 'brutto. È possibile trasmettere un intero stream a un tipo diverso? Come cast Stream<Object>a un Stream<Client>?

Si prega di ignorare il fatto che fare cose del genere significherebbe probabilmente un cattivo design. Facciamo cose del genere durante la mia lezione di informatica, quindi stavo esaminando le nuove funzionalità di Java 8 ed ero curioso di sapere se fosse possibile.

Non penso che ci sia un modo per farlo immediatamente. Una soluzione forse più pulita sarebbe:

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

oppure, come suggerito nei commenti, è possibile utilizzare il castmetodo: il primo potrebbe essere più semplice da leggere:

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

Sulla falsariga della risposta di ggovan , faccio questo come segue:

/**
 * 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();
    }
}

Utilizzando questa funzione di supporto:

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

In ritardo alla festa, ma penso che sia una risposta utile.

flatMap sarebbe il modo più breve per farlo.

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

Se oè un Clientquindi creare un flusso con un singolo elemento, altrimenti utilizzare il flusso vuoto. Questi flussi verranno quindi appiattiti in a Stream<Client>.

Sembra un po 'brutto. È possibile trasmettere un intero stream a un tipo diverso? Come cast Stream<Object>a un Stream<Client>?

No, non sarebbe possibile. Questo non è nuovo in Java 8. Questo è specifico per i generici. A List<Object>non è un super tipo di List<String>, quindi non puoi semplicemente lanciare List<Object>a a List<String>.

Simile è il problema qui. Non puoi lanciare Stream<Object>a Stream<Client>. Ovviamente puoi lanciarlo indirettamente in questo modo:

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

ma questo non è sicuro e potrebbe non funzionare in fase di esecuzione. Il motivo alla base di ciò è che i generici in Java vengono implementati usando la cancellazione. Pertanto, non sono disponibili informazioni sul tipo su quale tipo Streamè in fase di esecuzione. È tutto giusto Stream.

A proposito, cosa c'è di sbagliato nel tuo approccio? Mi sta bene.