Power Catch-up

tl;dr

v9 (huge…)

v10

v11 [LTS]

v12

v13

Local Variable Type Inference JEP 286

var primitiveVal = 5;   // int
var doubleVal    = 5d;  // double

final var sl = new ArrayList<String>();

var letters = "";
for (var s : sl) {
    letters += s.toLowerCase();
}

// var: enable annotation w/ type infer
(var x, @NotNull var y) -> x + y;

Type inference: Styleguide

Milling Project Coin JEP 213

var inputStream = new FileInputStream(".gitignore");
try (inputStream) { … }

interface Version {
    byte[] digits();
    default String text() { return text(digits()); }
    private String text(byte[] version) { … }
}

Preview features Preview 12

javac --release xx --enable-preview

java --enable-preview …

switch in Java 8

    enum Direction {N, S, W, E}

    String switchExpressionJDK8(Direction way) {
        String result;
        switch (way) {
            case N:
                result = "Up";
                break;
            case S:
                result = "Down";
                break;
            case E:
            case W:
                result = "Somewhere left or right";
                break;
            default:
                throw new IllegalStateException("Huh?: " + way);
        }
        return result;
    }

Switch-Expression JEP 325 12 JEP 354 13 Preview

String switchExpressionPreview13(Direction way) {
    return switch (way) {                         (1)
        case N -> "Up";                           (2)
        case S -> { yield "Down"; }               (3)
        case E, W -> "Somewhere left or right";
        // default -> "Foo"                       (4)
    };
}

Text Blocks JEP 355 13 Preview

Object obj = engine.eval(
    "function hello() {\n" +
    "   print(\"Hi, world!\");\n" +
    "}\n" +
    "\n"  +
    "hello();\n"
    );

Object obj = engine.eval("""
    function hello() {
       print("Hi, world!");
    }

    hello();
    """);

Jigsaw JEP 201

module com.mysql.jdbc {
    requires java.sql;             // Module dependency
    exports com.mysql.jdbc;        // Export module package → enables access
    provides java.sql.Driver       // SPI: Provide service instance
        with com.mysql.jdbc.Driver;
}

javac -mp modulepath ...
java  -mp modulepath -m modulename/moduleclass

Immutable Collection Factories JEP 269

/* Comment sections would break ... */
List<Integer> listOfNumbers     = List.of(1, 2, 3, 4, 5/*, null*/);

Set<Integer> setOfNumbers       = Set.of(1, 2, 3, 4, 5/*, 1*/);

Map<String, String> mapOfString = Map.of("key1", "value1", "key2", "value2");

Map<String, String> moreMaps    = Map.ofEntries(
        Map.entry("key1", "value1"),
        Map.entry("key2", "value2")/*,
        Map.entry("key1", "value3")*/
);

Immutable collection copy

var listCopy = List.copyOf(originalList);  // independent, immutable copy
var setCopy  =  Set.copyOf(originalList);  // copy to other types
var mapCopy  =  Map.copyOf( … );

assert 3 == listCopy.size();  // ["a", "b", "a"]
assert 2 == setCopy.size();   // ["a", "b"]

// listCopy.add("z")          // → UnsupportedOperationException

Files & I/O

var txtPath = Path.of("src", "test", "resources", "sample.txt");         (1)
Path newPath = Path.of("src/test/resources/newfile.txt");

String fileContent = Files.readString(txtPath);                          (2)
// → "Nostrum iure ullam."

Files.writeString(newPath, "Nostrum lore.", StandardOpenOption.CREATE);  (3)

long firstMismatch = Files.mismatch(txtPath, newPath); // → 8  | JDK12   (4)

Transform & Generate Streams

var stream = Stream.of(-1, 0, 1, 21, 42);

stream.dropWhile(i -> i < 2)     // → [ 21, 42   ]
stream.takeWhile(i -> i < 2)     // → [ -1, 0, 1 ]

new ByteArrayInputStream(buf)
        .transferTo(System.out);    // InputStream → OutputStream

// Stream<T> iterate​(seedValue, nextTest, applyFunc)
Stream.iterate(2, i -> i < 999,  i -> i*i);     // → [2, 4, 16, 256]

Stream.ofNullable(null);                        // [ ]
Stream.ofNullable("Hi");                        // [ "Hi" ]

stream.filter(s -> !s.isEmpty)

stream.filter(Predicate.not(String::isEmpty))

stream.filter(not(String::isEmpty))

Enhanced Optional

var maybeInt = Optional.ofNullable( (Math.random()<0.5) ? 42 : null );

maybeInt.ifPresentOrElse(                       // … do either this or that
        (n) -> System.out.println(n),
        () -> System.out.println("Nada")   );

// Optional empty? → Build a new one on-the-fly…
var triedAgain = maybeInt.or( () -> Optional.of(-1) );

// Provide a stream → [] or [42]
Stream<Integer> intStream = maybeInt.stream();

// Yay! – complements isPresent()
assert maybeInt.isPresent() == !maybeInt.isEmpty();

New ProcessHandle and ProcessBuilder

Process sleeper = new ProcessBuilder("sleep", "10s").start();
ProcessHandle sleepHandle = sleeper.toHandle();

// Perform Runnables on process exit
sleepHandle.onExit().thenRun(                       // → CompletableFuture
        () -> out.println("`sleep` process exited")  );

out.println(sleepHandle.info());
// → [user: ben, cmd: /bin/sleep, args: [10s], startTime:…, totalTime: …]

// Find …
ProcessHandle jvm = ProcessHandle.current();              // … JVM,
Stream<ProcessHandle> all = ProcessHandle.allProcesses(); // … all processes
jvm.children().forEach(out::println);                     // … or childs

// Kill …
sleepHandle.destroy();

HTTP/2 Client JEP 110 JEP 321

HttpClient client = HttpClient.newBuilder()                              (1)
            .version(HttpClient.Version.HTTP_2)                          (2)
            .connectTimeout(Duration.ofSeconds(3)).build();

URI uri = URI.create("https://www.exxcellent.de/");
HttpRequest req = HttpRequest.newBuilder(uri)
        .header("Useragent", "MyDemo").GET().build();

var future = client.sendAsync(req, HttpResponse.BodyHandlers.ofString()) (3)
        .thenApply(HttpResponse::body)
        .thenAccept(System.out::println);

var expensiveOperation = Math.pow(12345, 9876);  // meanwhile do sth. else…
future.get();              // wait for completion of the background request

Reactive Streams

Deprecation of finalize()

REPLS: jshell JEP 222

$ jshell
|  Welcome to JShell -- Version 13-ea
|  For an introduction type: /help intro

jshell> "HI"
$1 ==> "HI"

jshell> var hi = $1.to
toCharArray()   toLowerCase(    toString()      toUpperCase(
jshell> var hi = $1.toLowerCase()
hi ==> "hi"

jshell> String twice(String s) {
   ...>    return s + s;
   ...> }
|  created method twice(String)

jshell> var hihi = twice(hi)
hihi ==> "hihi"

jshell> /vars
|    String $1 = "HI"

|    String hi = "hi"
|    String hihi = "hihi"

jshell> /methods
|    String twice(String)

jshell> /edit twice
|  modified method twice(String)

jshell> /list

   1 : "HI"
   2 : var hi = $1.toLowerCase();
   4 : var hihi = twice(hi);
   5 : String twice(String s) {
          return "Double Time: "+ s + s;
       }

jshell> /4
var hihi = twice(hi);
hihi ==> "Double Time: hihi"

jshell> /save twice twice.jsh

Single Source File Launch JEP 330

#!/usr/bin/java --source 11

public class SingleClassJava {
    public static void main(String[] args) {
        System.out.println("Hello " + args[0] + ". Executable .java – Yay!");
    }
}

$ chmod +x hello
$ ./hello world
Hello world. Executable .java – Yay!

$ java SingleClassJava.java world

Flight Recorder JEP 328

Microbenchmark Suite JEP 230 12

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Thread)
public class BenchmarkIntegers {
    @Param("500")
    private int size;
    private String[] strings;

    @Setup
    public void setup() {
        Random r = new Random(0);
        strings = new String[size];
        for (int i = 0; i < size; i++) {
            strings[i] = "" + (r.nextInt(10000) - 5000);
        }
    }

    @Benchmark
    public void parseInt(Blackhole bh) {
        for (String s : strings) {
            bh.consume(Integer.parseInt(s));
        }
    }
}

Project Metropolis

GraalVM — Polyglot VM JEP 243 JEP 246 JEP 295

Simplyfing Syntax: Amber

if (obj instanceof String s) {
    return s.contains("abc")
}

(i, _) -> String.valueOf(i);

record Point(int x, int y) { }

Value Types: Valhalla

value class Rectangle { int width,height; }