É possível transmitir um fluxo no Java 8?

É possível transmitir um fluxo no Java 8? Digamos que eu tenha uma lista de objetos, posso fazer algo assim para filtrar todos os objetos adicionais:

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

Após isso, porém, se eu quiser fazer algo com os clientes, precisarei converter cada um deles:

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

Isso parece um pouco feio. É possível converter um fluxo inteiro para um tipo diferente? Como elenco Stream<Object>para um Stream<Client>?

Por favor, ignore o fato de que fazer coisas como essa provavelmente significaria um design ruim. Como fazemos coisas na minha aula de ciências da computação, eu estava analisando os novos recursos do java 8 e fiquei curioso para saber se isso era possível.

Eu não acho que exista uma maneira de fazer isso imediatamente. Uma solução possivelmente mais limpa seria:

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

ou, como sugerido nos comentários, você pode usar o castmétodo - o primeiro pode ser mais fácil de ler:

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

Na linha da resposta de ggovan , faço o seguinte:

/**
 * 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 função auxiliar:

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

Tarde para a festa, mas acho que é uma resposta útil.

flatMap seria a maneira mais curta de fazer isso.

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

Se ofor um Client, crie um fluxo com um único elemento, caso contrário, use o fluxo vazio. Esses fluxos serão achatados em a Stream<Client>.

Isso parece um pouco feio. É possível converter um fluxo inteiro para um tipo diferente? Como elenco Stream<Object>para um Stream<Client>?

Não, isso não seria possível. Isso não é novo no Java 8. Isso é específico para genéricos. A List<Object>não é um super tipo de List<String>, então você não pode simplesmente converter de a List<Object>para a List<String>.

Semelhante é o problema aqui. Você não pode lançar Stream<Object>para Stream<Client>. Claro que você pode transmiti-lo indiretamente assim:

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

mas isso não é seguro e pode falhar no tempo de execução. A razão subjacente para isso é que os genéricos em Java são implementados usando apagamento. Portanto, não há informações de tipo disponíveis sobre qual tipo Streamestá em tempo de execução. Tudo é justo Stream.

BTW, o que há de errado com sua abordagem? Parece bom para mim.