Java, what's next?

Java, what’s next?
by Stephan Janssen

• Founder of Devoxx

• Co-founder of Voxxed (Days)

• Co-founder Devoxx4Kids

• Java Champion

• Passionate Developer
Who am I ?

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

“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

@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

@Stephan007
New Java Versioning
• Java SE 18.3

@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

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

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

@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

@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

@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

@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

@Stephan007
Hidden compiler option
-XDﬁnd=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!

@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! 🤓

@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 eﬀectively ﬁnal anyway.”

- Brian Goetz

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

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

@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

@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
• Enum constants to carry constant-speciﬁc type information

• Constant-speciﬁc state and behavior.

JEP 302 Lambda Leftovers

@Stephan007
Treatment of underscores
• Use an uncerscore for unnamed lambda parameters
BiFunction<Integer, String, String> biss = (i, _) -> String.valueOf(i);

@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!

@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/

@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);
}

@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”;
}

@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

@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"
}

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

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

@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);
}
}

Data Classes
“Just data, no identiy”

@Stephan007
public class Point(int x, int y) { }

@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

JEP 218 Generics over Primitive Types

@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; }
}
• Suppose we want to specialize the following class with T=int

@Stephan007
• Project Amber

• Project Valhalla

• Project Panama - Interconnecting JVM and native code

• Project Loom - Make Concurrency simple(r) again!

• Project Metropolis - The holy Graal

IF expressions
Even better, change all statements into expressions 🤓

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

Java, what's next?

More Related Content

What's hot (19)

Similar to Java, what's next? (20)

More from Stephan Janssen (17)

Recently uploaded (20)

Java, what's next?