According to Mark Reinhold we can expect (after Java 9) a time-based model with a new feature release every six months, update releases every quarter, and a long-term support release every three years. This session will have a closer look at the possible Java language features we can expect in the near future.

1. Java, what’s next?
by Stephan Janssen

2. • Founder of Devoxx
• Co-founder of Voxxed (Days)
• Co-founder Devoxx4Kids
• Java Champion
• Passionate Developer
Who am I ?

3. “The Future Is Complicated”
- John Rose , JVM Architect

4. “For Java to remain competitive it
must not just continue to move
forward — it must move forward
faster.”
- Mark Reinhold , Chief Architect of the Java Platform Group at Oracle

5. @Stephan007
More Java Releases
• Every 6 months feature releases (March, September)
• Long-term support releases every 3 years
• Next release for March 2018
• Details @ https://mreinhold.org/blog/forward-faster

6. @Stephan007
New Java Versioning
• Java SE 18.3

7. @Stephan007
• Project Amber
• Project Valhalla
• Project Panama - Interconnecting JVM and native code
• Project Loom - Make Concurrency simple(r) again!
• Project Metropolis - The holy Graal : a Java compiler & interpreter

8. How will this effect you?

9. @Stephan007
Project Amber

10. @Stephan007
Project Amber
• Local-Variable Type Inference
• Enhanced Enums
• Lambda Leftovers
• Pattern matching
• Switch expression
https://openjdk.java.net/projects/amber/

11. JEP 286 Local-Variable Type Inference (LVTI)
(Java 18.3 target release)

12. @Stephan007
Expanded Type Inference
List<String> empty = Collections.<String>emptyList();
List<String> empty = Collections.emptyList();
• Java 5: type inference for generic method type arguments
• Java 7: type inference for constructor type arguments
List<String> newList = new ArrayList<String>();
List<String> newList = new ArrayList<>();
• Java 8: type inference for lambda formals
Predicate<String> isEmpty = (String s) -> s.isEmpty();
Predicate<String> isEmpty = s -> s.isEmpty();
Brian Goetz @ http://bit.ly/2x3Wop9

13. @Stephan007
Local-Variable
Type Inference (JEP 286)
URL url = new URL(“https://devoxx.com");
URLConnection conn = url.openConnection();
Scanner scanner = new Scanner(conn.getInputStream(), “UTF-8”);
var url = new URL(“https://devoxx.com");
var conn = url.openConnection();
var scanner = new Scanner(conn.getInputStream(), “UTF-8”);
Brian Goetz @ http://bit.ly/2x3Wop9

14. @Stephan007
LVTI warnings
var x = { 1, 2, 3 }; // array initializer needs an explicit target-type
http://cr.openjdk.java.net/~mcimadamore/8177466/lvti-diags.html
var x = null; // variable initializer is 'null'
var x; // cannot use 'var' on variable without initializer
var x = m(x); // cannot use 'var' on self-referencing variable
class var { } // as of release 9, 'var' is a restricted local variable type

15. @Stephan007
LVTI warnings
var[] x = s; // ‘var' is not allowed as an element type of an array
http://cr.openjdk.java.net/~mcimadamore/8177466/lvti-diags.html
var x = 1, y = 2; // 'var' is not allowed in a compound declaration
var<String> list() { return null; } // illegal ref to restricted type 'var'
var x = () -> { }; // lambda expression needs an explicit target-type

16. @Stephan007
Hidden compiler option
-XDfind=local
Detect local variables whose declared type can be replaced by 'var'
http://mail.openjdk.java.net/pipermail/compiler-dev/2017-September/011060.html
class TestLVTI {
void test() {
String s2 = "";
for (String s = s2 ; s != "" ; ) { }
Object o = "";
}
}
TestLVTI.java:3: warning: Redundant type for local variable (replace
explicit type with 'var').
String s2 = "";
^
TestLVTI.java:4: warning: Redundant type for local variable (replace
explicit type with 'var').
for (String s = s2 ; s != "" ; ) { }
^
2 warnings
The type of o is not redundant!

17. @Stephan007
Other JVM Languages
Groovy Kotlin
def robot = new Robot() // mutable property
var name = “Hello”
// Read-only
// there's no 'new' keyword
val result = Address()
Scala & Lombok
// Mutable
var name = ”Hello”
// Read-only
val result = new Address()
BTW None of these JVM languages demand a semi-colon! 🤓

18. @Stephan007
Immutability?
http://mail.openjdk.java.net/pipermail/platform-jep-discuss/2016-December/000066.html
“Local variables are in reality the least
important place where we need more
help making things immutable.
Local variables are immune to data races;
most locals are effectively final anyway.”
- Brian Goetz

19. @Stephan007
Project Amber
• JEP 286 Local-Variable Type Inference
• JEP 301 Enhanced Enums
• JEP 302 Lambda Leftovers

20. JEP 301 Enhanced Enums
http://openjdk.java.net/jeps/301

21. @Stephan007
Generic Enums
“Enhance the expressiveness of the enum construct in the
Java Language by allowing type-variables in enums, and
performing sharper type-checking for enum constants.”
- Maurizio Cimadamore
http://openjdk.java.net/jeps/301

22. @Stephan007
Enum enhancements
enum Argument<X> { // declares generic enum
STRING<String>(String.class),
INTEGER<Integer>(Integer.class), ... ;
Class<X> clazz;
Argument(Class<X> clazz) { this.clazz = clazz; }
Class<X> getClazz() { return clazz; }
}
Class<String> cs = Argument.STRING.getClazz(); //uses sharper typing of enum constant
http://openjdk.java.net/jeps/301
• Enum constants to carry constant-specific type information
• Constant-specific state and behavior.

23. JEP 302 Lambda Leftovers
http://openjdk.java.net/jeps/302

24. @Stephan007
Treatment of underscores
• Use an uncerscore for unnamed lambda parameters
BiFunction<Integer, String, String> biss = (i, _) -> String.valueOf(i);
http://openjdk.java.net/jeps/302

25. @Stephan007
Shadowing a lambda parameter
• Allow lambda parameters to shadow variables in enclosing scopes.
• And locals declared with a lambda.
Map<String, Integer> msi = …
…
String key = computeSomeKey();
msi.comuteIfAbstent(key, key -> key.length()); // error!
http://openjdk.java.net/jeps/302

26. Pattern Matching

27. @Stephan007
String formatted = “unknown”;
if (constant instanceof Integer) {
int i = (Integer)constant;
formatted = String.format(“int %d”, i);
} else if (constant instanceof Byte) {
byte b = (Byte)constant;
formatted = String.format(“byte %d”, b);
} // …
https://www.voxxed.com/2017/08/pattern-matching-java/

28. @Stephan007
Pattern Matching
String formatted = “unknown”;
switch(constant) {
case Integer i :
formatted = String.format(“int %d”, i); break;
case Byte b :
formatted = String.format(“byte %d”, b); break;
// …
default: formatted = String.format(“Unknown: %s”, constant);
}
https://www.voxxed.com/2017/08/pattern-matching-java/

29. @Stephan007
Switch Expression
String formatted =
switch(constant) {
case Integer i -> String.format(“int %d”, i);
case Byte b -> String.format(“byte %d”, b);
case Long l -> String.format(“long %d”, l);
case Double d -> String.format(“double %f”, d);
case String s -> String.format(“string %s”, s);
default -> “Unknown”;
}
https://www.voxxed.com/2017/08/pattern-matching-java/

30. @Stephan007
Enhanced Switch Expression
Shape s = …
double area = switch (shape) {
case Circle(var center, var radius)
-> PI * radius * radius;
case Square(var lowerLeft, var edge)
-> edge * edge;
case Rect(var lowerLeft, var upperRight)
-> (upperRight.x - lowerLeft.x)
* (upperRight.y - lowerLeft.y);
// …
}
interface Shape { }
class Circle implements Shape {
Point center;
double radius;
}
class Square implements Shape {
Point lowerLeft;
double edge;
}
class Rect implements Shape {
Point lowerLeft;
Point upperRight;
}
JavaOne 2017 keynote : https://www.youtube.com/watch?v=Tf5rlIS6tkg

31. @Stephan007
val x = Random.nextInt(10)
val value = x match {
case 0 => “zero”
case 1 => "one"
case 2 => "two"
case _ => "many"
}
val value = when(x) {
0 -> “zero”
1 -> "one"
2 -> "two"
else -> "many"
}

32. @Stephan007
Valhalla

33. JEP 169 Value Types
“Codes like a class, works like an int!”

34. @Stephan007
public class Point {
final int x;
final int y;
}
http://cr.openjdk.java.net/~jrose/values/values-0.html

35. @Stephan007
public class Point {
final int x;
final int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public boolean equals(Object o) {
return o instanceof Point && x == ((Point)o).x && y == ((Point)o).y;
}
public int hashCode() {
return x + 31 * y;
}
public String toString() {
return String.format(“Point[%d,%d]”, x, y);
}
}
http://cr.openjdk.java.net/~jrose/values/values-0.html

36. Data Classes
“Just data, no identiy”

37. @Stephan007
public class Point(int x, int y) { }
http://cr.openjdk.java.net/~jrose/values/values-0.html

38. @Stephan007
Value Types Requirements
• Final, not extensible
• Only interface parents
• Immutable fields
• No identity
• Equality based on state
• No recursive definitions
• Non-nullable values
• Value semantics
• No (representational) polymorphism
• Multiple fields supported

39. JEP 218 Generics over Primitive Types

40. ArrayList<int>

41. @Stephan007
Generic type arguments are
constrained to extend Object
• Supporting generic primitive and value types arguments!
class Box<T> {
private final T t;
public Box(T t) { this.t = t; }
public T get() { return t; }
}
http://openjdk.java.net/jeps/218
• Suppose we want to specialize the following class with T=int

42. @Stephan007
• Project Amber
• Project Valhalla
• Project Panama - Interconnecting JVM and native code
• Project Loom - Make Concurrency simple(r) again!
• Project Metropolis - The holy Graal

43. Personal Wishlist

44. IF expressions
Even better, change all statements into expressions 🤓

46. @Stephan007
Resources :
Brian Goetz - Java Language Architect, Oracle John Rose, JVM Architect, Oracle

47. November 22nd, 2017