Est-il possible de diffuser un flux en Java 8?

Est-il possible de diffuser un flux en Java 8? Disons que j'ai une liste d'objets, je peux faire quelque chose comme ceci pour filtrer tous les objets supplémentaires:

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

Après cela, si je veux faire quelque chose avec les clients, j'aurais besoin de lancer chacun d'eux:

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

Cela a l'air un peu moche. Est-il possible de diffuser un flux entier vers un type différent? Comme jeté Stream<Object>un Stream<Client>?

Veuillez ignorer le fait que faire de telles choses signifierait probablement une mauvaise conception. Nous faisons des trucs comme ça dans mon cours d'informatique, donc je cherchais les nouvelles fonctionnalités de java 8 et j'étais curieux de savoir si c'était possible.

Je ne pense pas qu'il y ait un moyen de faire cela hors de la boîte. Une solution éventuellement plus propre serait:

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

ou, comme suggéré dans les commentaires, vous pouvez utiliser la castméthode - la première peut être plus facile à lire cependant:

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

Le long des lignes de la réponse ggovan , je fais ceci comme suit:

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

Utilisation de cette fonction d'assistance:

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

En retard à la fête, mais je pense que c'est une réponse utile.

flatMap serait le moyen le plus court de le faire.

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

Si oest un Clientalors créez un Stream avec un seul élément, sinon utilisez le flux vide. Ces flux seront ensuite aplatis en un fichier Stream<Client>.

Cela a l'air un peu moche. Est-il possible de diffuser un flux entier vers un type différent? Comme jeté Stream<Object>un Stream<Client>?

Non, ce ne serait pas possible. Ce n'est pas nouveau dans Java 8. Ceci est spécifique aux génériques. A List<Object>n'est pas un super type de List<String>, vous ne pouvez donc pas simplement convertir un List<Object>en un List<String>.

Le problème est similaire ici. Vous ne pouvez pas lancer Stream<Object>vers Stream<Client>. Bien sûr, vous pouvez le lancer indirectement comme ceci:

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

mais ce n'est pas sûr et peut échouer à l'exécution. La raison sous-jacente à cela est que les génériques en Java sont implémentés à l'aide de l'effacement. Par conséquent, aucune information de type n'est disponible sur le type de Streamcelui-ci au moment de l'exécution. Tout est juste Stream.

BTW, quel est le problème avec votre approche? Ça me va.