57. Tackling type patterns for instanceof and streams
Let’s consider a List<Engine> where Engine is an interface implemented by several classes such as HypersonicEngine, HighSpeedEngine, and RegularEngine. Our goal is to filter this List and eliminate all RegularEngine that are electric and cannot pass our autonomy test. So, we can write a code as follows:
public static List<Engine> filterRegularEngines(
List<Engine> engines, int testSpeed) {
for (Iterator<Engine> i = engines.iterator(); i.hasNext();){
final Engine e = i.next();
if (e instanceof RegularEngine) {
final RegularEngine popularEngine = (RegularEngine) e;
if (popularEngine.isElectric()) {
if (!hasEnoughAutonomy(popularEngine, testSpeed)) {
i.remove();
}
}
}
}
return engines;
}
But, starting with JDK 8, we can safely remove from a List without using an Iterator via a default method from java.util.Collection named, public default boolean removeIf(Predicate<? super E> filter). If we combine this method (and therefore the Stream API) with type patterns for instanceof then we can simplify the previous code as follows:
public static List<Engine> filterRegularEngines(
List<Engine> engines, int testSpeed) {
engines.removeIf(e -> e instanceof RegularEngine engine
&& engine.isElectric()
&& !hasEnoughAutonomy(engine, testSpeed));
return engines;
}
So, whenever you have the chance to use type patterns with Stream API don’t hesitate.
58. Introducing type patterns matching for switch
JDK 17 (JEP 406) added type pattern matching for switch as a preview feature. A second preview was available in JDK 18 (JEP 420). In JDK 19 and 20 … note for me.Type pattern matching for switch allows the selector expression (that is o in switch(o)) to be of any type not just enum constant, number, or string. By “any type” I mean any type (any object type, enum type, array type, record type, sealed type)! The type pattern matching is not limited to a single hierarchy as it happens in the case of inheritance polymorphism. The case labels can have type patterns (referred to as case pattern labels or simply pattern labels), so the selector expression (o) can be matched against a type pattern not only against a constant.In the next snippet of code, we rewrote the example from Problem 53, Introducing type pattern matching for instanceof, via type pattern for switch:
public static String save(Object o) throws IOException {
return switch(o) {
case File file -> “Saving a file of size: “
+ String.format(“%,d bytes”, file.length());
case Path path -> “Saving a file of size: “
+ String.format(“%,d bytes”, Files.size(path));
case String str -> “Saving a string of size: “
+ String.format(“%,d bytes”, str.length());
case null -> “Why are you doing this?”;
default -> “I cannot save the given object”;
};
}
The following figure identifies the main players of a switch branch.
Figure 2.33 – Type pattern matching for switch
The case for null is not mandatory. We have added it just for the sake of completeness. On the other hand, the default branch is a must, but this topic is covered later in this chapter.