Along the lines of ggovan's answer, I do this as follows:

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

Using this helper function:

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

Late to the party, but I think it is a useful answer.

flatMap would be the shortest way to do it.

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

If o is a Client then create a Stream with a single element, otherwise use the empty stream. These streams will then be flattened into a Stream<Client>.

This looks a little ugly. Is it possible to cast an entire stream to a different type? Like cast Stream<Object> to a Stream<Client>?

No that wouldn't be possible. This is not new in Java 8. This is specific to generics. A List<Object> is not a super type of List<String>, so you can't just cast a List<Object> to a List<String>.

Similar is the issue here. You can't cast Stream<Object> to Stream<Client>. Of course you can cast it indirectly like this:

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

but that is not safe, and might fail at runtime. The underlying reason for this is, generics in Java are implemented using erasure. So, there is no type information available about which type of Stream it is at runtime. Everything is just Stream.

BTW, what's wrong with your approach? Looks fine to me.

The Stream.mapMulti method added in Java 16 can be used to cast and keep each element of the given type, skipping and excluding elements not of that type. In fact, using mapMulti in this way to filter and cast the stream is one of the examples shown in the method Javadocs:

Examples

Given a stream of Number objects, the following produces a list containing only the Integer objects:

 Stream<Number> numbers = ... ; List<Integer> integers = numbers.<Integer>mapMulti((number, consumer) -> { if (number instanceof Integer i) consumer.accept(i); }) .collect(Collectors.toList()); 

If you're doing a lot of such casting, you could create a resuable casting method that accepts the type to be cast to:

private static <T> BiConsumer<Object, Consumer<T>> casting(Class<T> clazz) { return (value, mapper) -> { if (clazz.isInstance(value)) { mapper.accept(clazz.cast(value)); } }; } // ... List<Integer> integers = numbers.mapMulti(casting(Integer.class)).toList(); 

Here is a solution using a reusable Gatherer per the JEP 485: Stream Gatherers Java 24 language feature (available as a preview language feature since Java 22)

Gatherer<Object, Void, Integer> cast = Gatherer.of(Integrator.ofGreedy((state, element, downstream) -> { if (element instanceof Integer i) { return downstream.push(i); } else { return true; } })); // Returns [1, 2, 4, 5, 10] List<Integer> integers = Stream.of(1, 2, 3.0, 4, 5, 6.0, true, 8L, "nine", 10) .gather(cast) .toList(); 

Or, the same thing but behind a generic method to cast to a requested type:

static <T> Gatherer<Object, ?, T> casting(Class<T> clazz) { return Gatherer.of(Integrator.ofGreedy((state, element, downstream) -> { if (clazz.isInstance(element)) { return downstream.push(clazz.cast(element)); } else { return true; } })); } // ... // Returns [1, 2, 4, 5, 10] List<Integer> integers = Stream.of(1, 2, 3.0, 4, 5, 6.0, true, 8L, "nine", 10) .gather(casting(Integer.class)) .toList(); 

This custom gatherer casts and keeps all elements of the given type, and skips any elements that aren't of that type.

Javadocs

Gatherer:

An intermediate operation that transforms a stream of input elements into a stream of output elements, optionally applying a final action when the end of the upstream is reached. […]

[…]

There are many examples of gathering operations, including but not limited to: grouping elements into batches (windowing functions); de-duplicating consecutively similar elements; incremental accumulation functions (prefix scan); incremental reordering functions, etc. The class Gatherers provides implementations of common gathering operations.

API Note:

A Gatherer is specified by four functions that work together to process input elements, optionally using intermediate state, and optionally perform a final action at the end of input. They are:

• creating a new, potentially mutable, state (initializer())
• integrating a new input element (integrator())
• combining two states into one (combiner())
• performing an optional final action (finisher())

Stream.gather(Gatherer<? super T,?,R> gatherer):

Returns a stream consisting of the results of applying the given gatherer to the elements of this stream.

Gatherer.of(Gatherer.Integrator<Void,T,R> integrator)

Returns a new, parallelizable, and stateless Gatherer described by the given integrator.

I found when dealing with an untyped collection of one class you can create a typed collection with

UntypedObjCollection bag = some preGenerics method; List<Foo> foolist = new ArrayList<>(); bag.stream().forEach(o ->fooList.add((Foo)o)); 

There doesn't seem to be a way to cast Object into something and filter, map, etc... in one shot. The only way to get Object into a typed collection is a terminal operation. This is running JDK 17 and dealing with module.base exceptions when trying less granular methods.