Filter elements from a Java 8 stream that reference a certain subtype with a certain attribute - java-stream

Question

I have a list of Cars where each car has an engine that is defined through the Engine interface. In this example concrete types are CombustionEngine, with a variable number of cylinders, and ElectricMotor.
I want to find all (combustion) engines with four cylinders. Using Java streams I came up with this pipeline:
Car[] carsWithFourCylinders
= cars.stream()
.filter( car -> car.engine instanceof CombustionEngine )
.filter( car -> ( ( CombustionEngine )car.engine ).cylinderCount == 4 )
.toArray( Car[]::new );
While this works, I was wondering if it is possible to avoid the cast in the second filter predicate or to rewrite the pipeline altogether to be more readable?
For reference and in order to experiemnt with I've attached the full source of the example:
public class CarTest {
interface Engine { }
class CombustionEngine implements Engine {
final int cylinderCount;
CombustionEngine( int cylinderCount ) {
this.cylinderCount = cylinderCount;
}
}
class ElectricMotor implements Engine { }
class Car {
final Engine engine;
Car( Engine engine ) {
this.engine = engine;
}
}
#Test
public void filterCarsWithFourCylinders() {
List<Car> cars = Arrays.asList( new Car( new CombustionEngine( 4 ) ),
new Car( new ElectricMotor() ),
new Car( new CombustionEngine( 6 ) ) );
Car[] carsWithFourCylinders
= cars.stream()
.filter( car -> car.engine instanceof CombustionEngine )
.filter( car -> ( ( CombustionEngine )car.engine ).cylinderCount == 4 )
.toArray( Car[]::new );
assertEquals( 1, carsWithFourCylinders.length );
}
}

Answer 1

I don't think it is possible to avoid the cast. After all, neither Car nor Engine provide any methods which make it possible to differentiate between electric cars and those with an ICE.
But if your Engine has no methods, in my opinion it means it should not matter to the Car what kind of engine a it has.
The best I could come up with is
final List<Car> combustionCars = cars.stream()
.collect(groupingBy(c -> c.engine.getClass()))
.get(CombustionEngine.class);
long count = combustionCars
.stream()
.map(Car::getEngine)
.map(CombustionEngine.class::cast)
.filter(c -> c.cylinderCount == 4).collect(Collectors.counting());
but I am not sure if this is more readable.