Pattern Matching in Java 14

1
Java 14 Pattern Matching
Oleksandr Navka
Lead Software Engineer, Consultant, GlobalLogic

2
1. Updated instanceof
2. Updated switch-case
3. Java Records
Agenda

3
Тагир Валеев
JetBrains
Pattern matching
и его воображаемые друзья

5
When someone match something :)
What is pattern matching?

6
Any pattern
• _
Constant pattern
• 1
• true
• null
Type pattern
• String s
Var pattern
• var i = 1
Deconstruction pattern
• Optional(String s)
• Node(Node left, Node right)
What are the patterns?

8
public class Animal {
}
class Dog extends Animal {
public void bark() {
}
}
class Cat extends Animal {
public void meow() {
}
}

9
public static void say(Animal animal) {
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.bark();
} else if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.meow();
}
}

10
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.bark();
} else if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.meow();
}
}

11
if (animal instanceof Dog dog) {
dog.bark();
} else if (animal instanceof Cat cat) {
cat.meow();
}
}

12
if (animal instanceof Dog dog) {
dog.bark();
} else if (animal instanceof Cat cat) {
cat.meow();
}
}

13
Before:
expression istanceof Type
Now:
expression instanceof Pattern

15
if (obj instanceof String s) {
// can use s here
} else {
// can't use s here
}

16
if (obj instanceof String s) {
// can use s here
} else {
// can't use s here
}
binding variable

17
if (!(obj instanceof String s)) {
} else {
s.contains("a")
}

18
if(obj instanceof String s && s.length() > 5) {
System.out.println(s.toUpperCase());
}

19
if(obj instanceof String s || s.length() > 5) {
}

20
if(!(obj instanceof String s) || s.length() > 5) {
System.out.println("Do something");
} else {
}

21
System.out.println("Do something");
} else {
}

22
throw new IllegalArgumentException();
}

23
}

24
s.contains(..)
} else {
s.contains(..)
}

25
private String s = "abc";
s.contains(..)
} else {
s.contains(..)
}

26
1. if (obj instanceof String s) {s.trim()}
2. if (!(obj instanceof String s)) {} else {s.contains("a")}
3. if(obj instanceof String s && s.length() > 5) {}
4. if(obj instanceof String s || s.length() > 5) {}
Binding variable scope

27

28
5. if(!(obj instanceof String s) || s.length() > 5) {}
6. if(!(obj instanceof String s) || s.length() > 5) {} else {s.toUpperCase());}
7. if(!(obj instanceof String s) || s.length() > 5) {
}

29
1. instanceof has got type pattern matching
2. instanceof the first java feature that got pattern matching
3. Be aware about scoping
Instanceof Summary

31
public enum ProgrammingParadigm {OBJECT_ORIENTED, PROCEDURAL, FUNCTIONAL}
public static List<String> getProgrammingLanguage(ProgrammingParadigm programmingParadigm) {
List<String> languages = new ArrayList<>();
switch (programmingParadigm) {
case OBJECT_ORIENTED:
languages.add("Java");
languages.add("C++");
break;
case FUNCTIONAL:
languages.add("Haskel");
break;
case PROCEDURAL:
languages.add("Pascal");
break;
}
return languages;
}
Old version of switch

32
break;
case FUNCTIONAL:
break;
case PROCEDURAL:
break;
}
return languages;
}

33
break;
case FUNCTIONAL:
break;
case PROCEDURAL:
break;
}
return languages;
}
Input type limitations:
byte, short, char, and int
Enum Types, String

34
break;
case FUNCTIONAL:
break;
case PROCEDURAL:
break;
}
return languages;
}
Can’t
get
result

35
return List.of("Java", "C++");
case FUNCTIONAL:
return List.of("Haskel");
case PROCEDURAL:
return List.of("Pascal");
default:
return List.of();
}
}

36
return List.of("Java", "C++");
case FUNCTIONAL:
return List.of("Haskel");
case PROCEDURAL:
return List.of("Pascal");
default:
return List.of();
}
}

37
Disadvantages:
1. Always remember about break
2. Input data type limitation
3. Can’t get result
4. Don’t understand all possible options for enum

38
Pattern matching with switch case

39
public void printObject(Object obj) {
switch (obj) {
case String s:
System.out.println("This is String" + s.trim());
break;
case Integer i:
System.out.println("This is Integer" + i);
break;
case Number n:
System.out.println("This is number"+ n);
break;
default:
System.out.println("I don't know");
}
}

40
switch (obj) {
case String s:
break;
case Number n:
break;
case Integer i:
break;
default:
}
}

41
switch (obj) {
case String s:
break;
default:
case Number n:
break;
case Integer i:
break;
}
}

43
return switch (programmingParadigm) {
case OBJECT_ORIENTED -> List.of("Java", "C++");
case FUNCTIONAL -> List.of("Haskel");
case PROCEDURAL -> List.of("Pascal");
};
}
Updated switch case

44
return switch (programmingParadigm) {
case OBJECT_ORIENTED -> {
System.out.println("You are master of polymorphism");
yield List.of("Java", "C++");
}
case FUNCTIONAL -> {
System.out.println("You are master of recursion");
yield List.of("Haskel");
}
case PROCEDURAL -> {
System.out.println("Try to use another paradigms");
yield List.of("Pascal");
}
};
}

45
1. Don’t need to use break
2. Can return result
3. Don’t need to use default branch if all options described
4. Input data types have limitations
Summary of updated switch

47
private record Car(int speed, String manufacturer) {
}
Java Records

48
}
public static void main(String[] args) {
Car car = new Car(100, "Mercedes");
System.out.println(car.speed());
System.out.println(car.manufacturer());
}
Java Records

49
}
Car car = new Car(100, "Mercedes");
System.out.println(car);
}
-------
Output:
Car[speed=100, manufacturer=Mercedes]
Java Records

50
private static final class Car extends java.lang.Record {
private final int speed;
private final java.lang.String manufacturer;
public Car(int speed, java.lang.String manufacturer) { /* compiled code */ }
public java.lang.String toString() { /* compiled code */ }
public final int hashCode() { /* compiled code */ }
public final boolean equals(java.lang.Object o) { /* compiled code */ }
public int speed() { /* compiled code */ }
public java.lang.String manufacturer() { /* compiled code */ }
}

51
}

52
public abstract class Record {
protected Record() {}
@Override
public abstract boolean equals(Object obj);
@Override
public abstract int hashCode();
@Override
public abstract String toString();
}

53
}

54
}

55
public Car {
if(speed < 0) {
}
}
}
var car = new Car(-2, "Mercedes");
System.out.println(car);
}
Canonical constructor

56
public Car {
if(speed < 0) {
}
}
public Car(String manufacturer) {
this(0, manufacturer);
}
}
Canonical constructor

57
}

58
}

59
1. Java 14 present first version of pattern matching
2. Type pattern matching present in instanceof operator
3. New Switch statement was released with some blanks for
pattern matching
4. Keep eye on Java Records and deconstruction patterns
Summary

Pattern Matching in Java 14

More Related Content

What's hot

Similar to Pattern Matching in Java 14

More from GlobalLogic Ukraine

Recently uploaded

Pattern Matching in Java 14