Java Next!

A Peek Under The Hood

#(int x, int y)(x * y)
Callable<String> c = () -> "done";
module jpms {
    requires more.work;
    exports migration.challenges;
}
var users = new ArrayList<User>();
java HelloWorld.java
String html =
    `<html>
        <body>
            <p>"Hello, string literals!"</p>
        </body>
    </html>`;
DayOfWeek day = // ...
int numLetters = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> 6;
    case TUESDAY -> 7;
    case THURSDAY, SATURDAY -> 8;
    case WEDNESDAY -> 9;
};
Object value = // ...
String formatted = switch (value) {
    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 " + value.toString();
}
Node n = // ...
int result = switch(n) {
    case IntNode(int i) -> i;
    case NegNode(Node n) -> -eval(n);
    case AddNode(Node left, Node right) ->
        eval(left) + eval(right);
    default -> throw new IllegalStateException(n);
};
public record Range(int low, int high) {

    // compiler generates:
    //  * constructor, deconstructor
    //  * equals/hashCode/toString
    //  * accessors low(), high()

}
public record Range(int low, int high) {

    // compiler knows signature and assigns to fields
    public Range {
        if (low > high)
            throw new IllegalArgumentException();
    }

    public void setLow(int low) {
        if (low > this.high)
            throw new IllegalArgumentException();
        this.low = low;
    }

}
public value Range {

    // implicitly final
    private int low;
    private int high;

    // you write:
    //  * constructor, static factories
    //  * equals/hashCode/toString
    //  * accessors, etc.

}
public value Range {
    private int low;
    private int high;
}
List<int> ids = new ArrayList<>();
public static void main(String[] args) {

    final int length = 8;
    int[] ina = new int[length];
    int[] inb = new int[length];
    int[] out = new int[length];

    // ...

}
// offloadable
IntStream.range(0, length).parallel().forEach(p -> {
    ina[p] = 1;
    inb[p] = 2;
});

// offloadable
IntStream.range(0, length).parallel().forEach(p -> {
    out[p] = ina[p] + inb[p];
});

// not offloadable (native code)
IntStream.range(0, length).forEach(p -> {
    System.out.println(
        out[p] + ", " + ina[p] + ", " + inb[p]);
});

Java Next!

New Releases, Amber, Valhalla, and More Goodies