¿Es posible emitir un Stream en Java 8?

¿Es posible emitir una transmisión en Java 8? Digamos que tengo una lista de objetos, puedo hacer algo como esto para filtrar todos los objetos adicionales:

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

Sin embargo, después de esto, si quiero hacer algo con los clientes, necesitaré lanzar cada uno de ellos:

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

Esto se ve un poco feo. ¿Es posible emitir una transmisión completa a un tipo diferente? ¿Como echar Stream<Object>a un Stream<Client>?

Ignore el hecho de que hacer cosas como esta probablemente significaría un mal diseño. Hacemos cosas como esta en mi clase de informática, así que estaba investigando las nuevas características de Java 8 y tenía curiosidad por saber si esto era posible.

No creo que haya una manera de hacer eso de forma inmediata. Una solución posiblemente más limpia sería:

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

o, como se sugiere en los comentarios, podría usar el castmétodo; sin embargo, el primero puede ser más fácil de leer:

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

En la línea de la respuesta de ggovan , hago esto de la siguiente manera:

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

Usando esta función auxiliar:

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

Tarde a la fiesta, pero creo que es una respuesta útil.

flatMap sería la forma más corta de hacerlo.

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

Si oes un Client, cree una secuencia con un solo elemento; de lo contrario, utilice la secuencia vacía. Estas corrientes se aplanarán en a Stream<Client>.

Esto se ve un poco feo. ¿Es posible emitir una transmisión completa a un tipo diferente? ¿Como echar Stream<Object>a un Stream<Client>?

No, eso no sería posible. Esto no es nuevo en Java 8. Esto es específico de los genéricos. A List<Object>no es un súper tipo de List<String>, por lo que no puedes simplemente lanzar un List<Object>a a List<String>.

Similar es el problema aquí. No puedes echar Stream<Object>a Stream<Client>. Por supuesto, puedes lanzarlo indirectamente de esta manera:

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

pero eso no es seguro y puede fallar en tiempo de ejecución. La razón subyacente de esto es que los genéricos en Java se implementan mediante borrado. Por lo tanto, no hay información de tipo disponible sobre qué tipo Streamestá en tiempo de ejecución. Todo es simplemente Stream.

Por cierto, ¿qué hay de malo en su enfoque? Luce bien para mi.