Ist es möglich, einen Stream in Java 8 zu übertragen?

Ist es möglich, einen Stream in Java 8 zu übertragen? Angenommen, ich habe eine Liste von Objekten. Ich kann so etwas tun, um alle zusätzlichen Objekte herauszufiltern:

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

Wenn ich danach etwas mit den Kunden machen möchte, muss ich jeden von ihnen besetzen:

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

Das sieht ein bisschen hässlich aus. Ist es möglich, einen ganzen Stream in einen anderen Typ umzuwandeln? Wie Stream<Object>zu einem gegossen Stream<Client>?

Bitte ignorieren Sie die Tatsache, dass solche Dinge wahrscheinlich schlechtes Design bedeuten würden. Wir machen solche Sachen in meinem Informatikkurs, also habe ich mir die neuen Funktionen von Java 8 angesehen und war neugierig, ob dies möglich ist.

Ich glaube nicht, dass es einen Weg gibt, dies sofort zu tun. Eine möglicherweise sauberere Lösung wäre:

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

oder, wie in den Kommentaren vorgeschlagen, können Sie die castMethode verwenden - die erstere ist jedoch möglicherweise leichter zu lesen:

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

In Anlehnung an Ggovans Antwort mache ich das wie folgt:

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

Verwenden dieser Hilfsfunktion:

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

Spät zur Party, aber ich denke, es ist eine nützliche Antwort.

flatMap wäre der kürzeste Weg, es zu tun.

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

Wenn dies der Fall oist, Clienterstellen Sie einen Stream mit einem einzelnen Element. Andernfalls verwenden Sie den leeren Stream. Diese Ströme werden dann zu a abgeflacht Stream<Client>.

Das sieht ein bisschen hässlich aus. Ist es möglich, einen ganzen Stream in einen anderen Typ umzuwandeln? Wie Stream<Object>zu einem gegossen Stream<Client>?

Nein, das wäre nicht möglich. Dies ist in Java 8 nicht neu. Dies gilt speziell für Generika. A List<Object>ist kein super Typ von List<String>, also kann man nicht einfach a List<Object>in a umwandeln List<String>.

Ähnlich ist das Problem hier. Sie können nicht werfen Stream<Object>zu Stream<Client>. Natürlich können Sie es indirekt so besetzen:

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

Dies ist jedoch nicht sicher und kann zur Laufzeit fehlschlagen. Der Grund dafür ist, dass Generika in Java durch Löschen implementiert werden. Es sind also keine Typinformationen darüber verfügbar, welcher Typ Streamzur Laufzeit vorhanden ist. Alles ist gerecht Stream.

Übrigens, was ist falsch an Ihrem Ansatz? Sieht gut aus für mich.