Java 16 Is Coming!

sealed interface Staff
	permits Employee, Freelancer { }

final class Employee implements Staff { }

final class Freelancer implements Staff { }

// compile error
final class Consultant implements Staff { }

public double cost(Staff staff) {
	return switch(staff) {
		// strawman syntax!
		case Employee employee ->
			employee.salary() * 2;
		case Freelancer freelander ->
			freelancer.averageInvoice() * 1.1;
		// compiler checks exhaustiveness
	}
}

sealed class Staff
	extends Person
	implements Comparable<Staff>
	permits Employee, Freelancer {

	// ...

}

sealed interface Staff
	permits Employee, Freelancer { }

non-sealed class Employee implements Staff { }

sealed class Freelancer implements Staff
	permits Consultant { }

final class Consultant extends Freelancer { }

sealed interface Staff
	//                 compile error
	permits Freelancer, Consultant { }

non-sealed class Freelancer implements Staff { }

class Consultant extends Freelancer { }

public class Employment {

	sealed interface Staff { }

	final class Employee implements Staff { }

	final class Freelancer implements Staff { }

}

public class Range {

	// part I 😀

	private final int low;
	private final int high;

	public Range(int low, int high) {
		this.low = low;
		this.high = high;
	}

}

public class Range {

	// part II 🙄

	public int getLow() {
		return low;
	}

	public int getHigh() {
		return high;
	}

}

public class Range {

	// part III 🤨

	@Override
	public boolean equals(Object o) {
		if (this == o)
			return true;
		if (o == null || getClass() != o.getClass())
			return false;
		Range range = (Range) o;
		return low == range.low &&
				high == range.high;
	}

}

public class Range {

	// part IV 🥴

	@Override
	public int hashCode() {
		return Objects.hash(low, high);
	}

}

public class Range {

	// part V 😭

	@Override
	public String toString() {
		return "[" + low + "; " + high + "]";
	}

}

//                these are "components"
public record Range(int low, int high) {

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

}

public Range(int low, int high) {
	if (high < low)
		throw new IllegalArgumentException();
	this.low = low;
	this.high = high;
}

// executed before fields are assigned
public Range {
	if (high < low)
		throw new IllegalArgumentException();
}

// arguments can be reassigned
public Range {
	if (high < low)
		high = low;
}

public Range(int high) {
	this(0, high);
}

public static Range open(int low, int high) {
	return new Range(low, high + 1);
}

@Deprecated
// use static factory method instead
public Range { }

@Override
public low() {
	return Math.max(0, low);
}

public record Range(int low, int high)
		implements Comparable<Range> {

	@Override
	public int compareTo(Range other) {
		return this.low == other.low
			? this.high - other.high
			: this.low - other.low;
	}

}

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

public void feed(Animal animal) {
	if (animal instanceof Elephant)
		((Elephant) animal).eatPlants();
	else if (animal instanceof Tiger)
		((Tiger) animal).eatMeat();
}

public void feed(Animal animal) {
	if (animal instanceof Elephant elephant)
		elephant.eatPlants();
	else if (animal instanceof Tiger tiger)
		tiger.eatMeat();
}

//         |--------- pattern --------|
//  target |----- test ------| variable
    animal instanceof Elephant elephant

public void inverted(Object object) {
	if (!(object instanceof String string))
		throw new IllegalArgumentException();
	// after inverted test
	System.out.println(string.length());
}

public void scoped(Object object) {
	// later in same expression
	if (object instanceof String string
			&& string.length() > 50)
		System.out.println("Long string");

	if (object instanceof String string
			// compiler error because || means
			// it's not necessarily a string
			|| string.length() > 50)
		System.out.println("Maybe string");
}

switch (animal) {
	case Elephant elephant
		-> elephant.eatPlants();
	case Tiger tiger
		-> tiger.eatMeat();
}

String haikuBlock = """
	worker bees can leave
	 even drones can fly away
	  the queen is their slave""";
System.out.println(haiku);
// > worker bees can leave
// >  even drones can fly away
// >   the queen is their slave

String haikuLiteral = ""
	+ "worker bees can leave\n"
	+ " even drones can fly away\n"
	+ "  the queen is their slave";

String windows = """
    Windows\r
    line\r
    endings\r
    """

String haikuBlock = """
		|worker bees can leave
		| even drones can fly away
		|  the queen is their slave""";
String haikuBlock = """
	|	worker bees can leave
	|	 even drones can fly away
	|	  the queen is their slave
	""";

String phrase = """
    {
        greeting: "hello",
        audience: "text blocks",
    }
    """;

public enum TernaryBoolean {
	TRUE,
	FALSE,
	FILE_NOT_FOUND
}

boolean result;
switch (ternaryBool) {
	case TRUE: result = true; break;
	case FALSE: result = false; break;
	case FILE_NOT_FOUND:
		var ex = new UncheckedIOException(
			"This is ridiculous!",
			new FileNotFoundException());
		throw ex;
	default:
		var ex2 = new IllegalArgumentException(
			"Seriously?! 😠");
		throw ex2;
}

public boolean convert(TernaryBoolean ternaryBool) {
	switch (ternaryBool) {
		case TRUE: return true;
		case FALSE: return false;
		case FILE_NOT_FOUND:
			throw new UncheckedIOException(
				"This is ridiculous!",
				new FileNotFoundException());
		default:
			throw new IllegalArgumentException(
				"Seriously?! 😠");
	}
}

boolean result = switch(ternaryBool) {
    case TRUE -> true;
    case FALSE -> false;
    case FILE_NOT_FOUND ->
		throw new UncheckedIOException(
			"This is ridiculous!",
			new FileNotFoundException());
};

if (condition)
    result = doThis();
else
    result = doThat();

result = condition
	? doThis()
	: doThat();

boolean result = switch(ternaryBool) {
    case TRUE: yield true;
    case FALSE: yield false;
    case FILE_NOT_FOUND:
		throw new UncheckedIOException(
			"This is ridiculous!",
			new FileNotFoundException());
};

String result = switch (ternaryBool) {
	case TRUE, FALSE -> "sane";
	// `default, case FILE_NOT_FOUND -> ...`
	// does not work (neither does other way
	// around), but that makes sense because
	// using only `default` suffices
	default -> "insane";
};

switch (ternaryBool) {
	case TRUE, FALSE ->
		System.out.println("Bool was sane");
	// in colon-form, if `ternaryBool` is `TRUE`
	// or `FALSE`, we would see both messages;
	// in arrow-form, only one branch is executed
	default ->
		System.out.println("Bool was insane");
}

boolean result = switch (Bool.random()) {
    case TRUE -> {
        System.out.println("Bool true");
        yield true;
    }
    case FALSE -> {
        System.out.println("Bool false");
        yield false;
    }
	// cases `FILE_NOT_FOUND` and `default`
};

boolean result = switch (Bool.random()) {
	// cases `TRUE` and `FALSE`
    case FILE_NOT_FOUND -> {
        var ex = new UncheckedIOException(
            "This is ridiculous!",
            new FileNotFoundException());
        throw ex;
    }
    default -> {
        var ex = new IllegalArgumentException(
            "Seriously?! 🤬");
        throw ex;
    }
};

Function<String, String> fun = s -> s + " ";
UnaryOperator<String> op = s -> s + " ";

// target type known: String
String result = switch (ternaryBool) { ... }
// target type unknown
var result = switch (ternaryBool) { ... }

String result = switch (ternaryBool) {
    case TRUE, FALSE -> "sane";
    default -> "insane";
};

// compiler infers super type of `String` and
// `IllegalArgumentException` ~> `Serializable`
var serializableMessage = switch (bool) {
    case TRUE, FALSE -> "sane";
    default -> new IllegalArgumentException("insane");
};

public String sanity(Bool ternaryBool) {
    String result = switch (ternaryBool) {
        // compile error:
		//     "return outside
		//      of enclosing switch expression"
        case TRUE, FALSE -> { return "sane"; }
        default -> { return "This is ridiculous!"; }
    };
}

// compile error:
//     "the switch expression does not cover
//      all possible input values"
boolean result = switch (ternaryBool) {
    case TRUE -> true;
    // no case for `FALSE`
    case FILE_NOT_FOUND ->
		throw new UncheckedIOException(
			"This is ridiculous!",
			new FileNotFoundException());
};

// compiles without `default` branch because
// all cases for `ternaryBool` are covered
boolean result = switch (ternaryBool) {
    case TRUE -> true;
    case FALSE -> false;
    case FILE_NOT_FOUND ->
		throw new UncheckedIOException(
			"This is ridiculous!",
			new FileNotFoundException());
};

URL nipafx = new URL("https://nipafx.dev");
URLConnection connection = nipafx.openConnection();
Reader reader = new BufferedReader(
	new InputStreamReader(
		connection.getInputStream()));

No no = new No();
AmountIncrease<BigDecimal> more =
	new BigDecimalAmountIncrease();
HorizontalConnection<LinePosition, LinePosition>
	jumping =
		new HorizontalLinePositionConnection();
Variable variable = new Constant(5);
List<String> names = List.of("Max", "Maria");

var nipafx = new URL("https://nipafx.dev");
var connection = nipafx.openConnection();
var reader = new BufferedReader(
	new InputStreamReader(
		connection.getInputStream()));

// inferred as `int`
var id = 123;
if (id < 100) {
	// very long branch
} else {
	// oh boy, much more code...
}

// now we add this line:
id = "124";

var no = new No();
var more = new BigDecimalAmountIncrease();
var jumping = new HorizontalLinePositionConnection();
var variable = new Constant(5);
var names = List.of("Max", "Maria");

rhetoricalQuestion.answer(yes -> "see my point?");

/* ✘ */ var u = UserRepository.findUser(id);
/* ✔ */ var user = UserRepository.findUser(id);
/* 👍*/ var userToLogIn = UserRepository.findUser(id);

// ✘
var id = 123;
if (id < 100) {
	// very long branch
} else {
	// oh boy, much more code...
}
LOGGER.info("... " + id);

// ✔ replace branches with method calls

/* ✘ */ var user = Repository.find(id);
/* ✔ */ var user = UserRepository.findUser(id);
/* 👍*/ var user = new User(id);

// ✘
return Canvas
	.activeCanvas()
	.drawings()
	.filter(Drawing::isLine)
	.map(drawing -> (HorizontalConnection) drawing)
		// now we have lines
	.filter(line -> length(line) == 7)
	.map(this::generateSquare)
		// now we have squares
	.map(this::createRandomColoredSquare)
	.map(this::createRandomBorderedSquare)
	.collect(toList());

// ✔
var lines = Canvas
	.activeCanvas()
	.drawings()
	.filter(Drawing::isLine)
	.map(drawing -> (HorizontalConnection) drawing)
var squares = lines
	.filter(line -> length(line) == 7)
	.map(this::generateSquare);
return squares
	.map(this::createRandomColoredSquare)
	.map(this::createRandomBorderedSquare)
	.collect(toList());

// inferred as `ArrayList` (not `List`),
// but that's ok
var users = new ArrayList<User>();

// ✘ infers `ArrayList<Object>`
var users = new ArrayList<>();

// ✔ infers `ArrayList<User>`
var users = new ArrayList<User>();

// ✘ when used with `var`, these
//   variables become `int`
byte b = 42;
short s = 42;
long l = 42;

public interface InJava8 {

	default boolean evenSum(int... numbers) {
		return sum(numbers) % 2 == 0;
	}

	default boolean oddSum(int... numbers) {
		return sum(numbers) % 2 == 1;
	}

	default int sum(int[] numbers) {
		return IntStream.of(numbers).sum();
	}

}

public interface InJava9 {

	private int sum(int[] numbers) {
		return IntStream.of(numbers).sum();
	}

}

void doSomethingWith(Connection connection)
		throws Exception {
	try(Connection c = connection) {
		c.doSomething();
	}
}

try(Connection c = connection)

void doSomethingWith(Connection connection)
		throws Exception {
	try(connection) {
		connection.doSomething();
	}
}

List<String> strings = new ArrayList<>();

<T> Box<T> createBox(T content) {
	// we have to put the `T` here :(
	return new Box<T>(content) { };
}

<T> Box<T> createBox(T content) {
	return new Box<>(content) { };
}

Box<?> createCrazyBox(Object content) {
	List<?> innerList = Arrays.asList(content);
	// compile error
	return new Box<>(innerList) { };
}

private <T> Optional<T> firstNonNull(T... args) {
	return stream(args)
			.filter(Objects::nonNull)
			.findFirst();
}

Possible heap pollution from
parameterized vararg type

private <T> T[] replaceTwoNulls(
		T value, T first, T second) {
	return replaceAllNulls(value, first, second);
}

private <T> T[] replaceAllNulls(T value, T... args) {
	// loop over `args`, replacing `null` with `value`
	return args;
}

@SafeVarargs
private <T> Optional<T> firstNonNull(T... args) {
	return // [...]
}

Invalid SafeVarargs annotation. Instance
method <T>firstNonNull(T...) is not final.

// use Integer::valueOf instead
Integer answer = new Integer(42);
// don't synchronize on values
synchronize(answer) { /*... */ }

import java.io.LineNumberInputStream;

@Deprecated
public class DeprecatedImports {

	LineNumberInputStream stream;

}

String strip();
String stripLeading();
String stripTrailing();

" foo bar ".strip().equals("foo bar");

boolean isBlank();

string.isBlank() == string.strip().isEmpty();

Stream<String> lines();

String oneTwo = " one\n  two\n";
oneTwo.indent(0).equals(" one\n  two\n");
oneTwo.indent(1).equals("  one\n   two\n");
oneTwo.indent(-1).equals("one\n two\n");
oneTwo.indent(-2).equals("one\ntwo\n");

"1\n2".indent(0).equals("1\n2\n");
"1\r\n2".indent(0).equals("1\n2\n");
"1\r2\n".indent(0).equals("1\n2\n");
"1\n2\n".indent(0).equals("1\n2\n");

public <R> R transform(Function<String, R> f) {
	return f.apply(this);
}

User newUser = parse(clean(input));
User newUser = input
	.transform(this::clean)
	.transform(this::parse);

// in a museum...
tourists.stream()
	.map(this::letEnter)
	.transform(this::groupsOfFive)
	.forEach(this::giveTour)

Stream<TouristGroup> groupsOfFive(
	Stream<Tourist> tourists) {
	// this is not trivial,
	// but at least possible
}

long zero = Stream.ofNullable(null).count();
long one = Stream.ofNullable("42").count();

iterate(
	T seed,
	Predicate<T> hasNext,
	UnaryOperator<T> next);

Stream
	.iterate(1, i -> i<=10, i -> 2*i)
	.forEach(System.out::println);
// output: 1 2 4 8

Enumeration<Integer> en = // ...
Stream.iterate(
		en.nextElement(),
		el -> en.hasMoreElements(),
		el -> en.nextElement())
	.forEach(System.out::println);

Stream<T> takeWhile(Predicate<T> predicate);

Stream.of("a-", "b-", "c-", "", "e-")
	.takeWhile(s -> !s.isEmpty())
	.forEach(System.out::print);

// output: a-b-c-

Stream<T> dropWhile(Predicate<T> predicate);

Stream.of("a-", "b-", "c-", "de-", "f-")
	.dropWhile(s -> s.length() <= 2)
	.forEach(System.out::print);

// output: de-f-

Collector<T, ?, List<T>> toUnmodifiableList();

Collector<T, ?, Set<T>> toUnmodifiableSet();

Collector<T, ?, Map<K,U>> toUnmodifiableMap(
	Function<T, K> keyMapper,
	Function<T, U> valueMapper);
// plus overload with merge function

// on Collectors
Collector<T, ?, R> teeing(
	Collector<T, ?, R1> downstream1,
	Collector<T, ?, R2> downstream2,
	BiFunction<R1, R2, R> merger);

Statistics stats = Stream
	.of(1, 2, 4, 5)
	.collect(teeing(
		// Collector<Integer, ?, Integer>
		summingInt(i -> i),
		// Collector<Integer, ?, Double>
		averagingInt(i -> i),
		// BiFunction<Integer, Double, Statistics>
		Statistics::of));
// stats = Statistics {sum=12, average=3.0}

<R> Stream<R> mapMulti​(
	BiConsumer<T, Consumer<R>> mapper)

Stream.of(1, 2, 3, 4)
	// changes nothing, just passes on elements
	.mapMulti((el, ds) -> ds.accept(el));

Stream
	.of(Optional.of("0"), Optional.empty())
	// unpacks Optionals
	.mapMulti((el, ds) -> el.ifPresent(ds));

Stream
	.of(Optional.of("0"), Optional.empty())
	.mapMulti(Optional::ifPresent);

List<String> strings = Stream
	.of(Optional.of("0"), Optional.empty())
	// without <String>, collect returns List<Object>
	.<String> mapMulti(Optional::ifPresent)
	.collect(toList());

List<String> strings = Stream
	.of("A", "B", "C")
	// some stream stuff
	.toList()

Optional<T> or(Supplier<Optional<T>> supplier);

public interface Search {
	Optional<Customer> inMemory(String id);
	Optional<Customer> onDisk(String id);
	Optional<Customer> remotely(String id);

	default Optional<Customer> anywhere(String id) {
		return inMemory(id)
			.or(() -> onDisk(id))
			.or(() -> remotely(id));
	}

}

void ifPresentOrElse(
	Consumer<T> action,
	Runnable emptyAction);

void logLogin(String id) {
	findCustomer(id)
		.ifPresentOrElse(
			this::logCustomerLogin,
			() -> logUnknownLogin(id));
}

Stream<T> stream();

private Optional<Customer> findCustomer(String id) {
	// ...
}

Stream<Customer> findCustomers(List<String> ids) {
	return ids.stream()
		.map(this::findCustomer)
		// now we have a Stream<Optional<Customer>>
		.filter(Optional::isPresent)
		.map(Optional::get)
}

private Optional<Customer> findCustomer(String id) {
	// ...
}

Stream<Customer> findCustomers(List<String> ids) {
	return ids.stream()
		.map(this::findCustomer)
		// now we have a Stream<Optional<Customer>>
		// we can now filter-map in one step
		.flatMap(Optional::stream)
}

List<Order> findOrdersForCustomer(String id) {
	return findCustomer(id)
		.map(this::getOrders) // eager
		.orElse(new ArrayList<>());
}

Stream<Order> findOrdersForCustomer(String id) {
	return findCustomer(id)
		.stream()
		.map(this::getOrders) // lazy
		.flatMap(List::stream);
}

T orElseThrow()

T orElse(T other)
T orElseGet(Supplier<T> supplier)
T orElseThrow()
	throws NoSuchElementException
T orElseThrow(
	Supplier<EX> exceptionSupplier)
	throws EX

boolean isEmpty()

ls /home/nipa/tmp | grep pdf

Path dir = Paths.get("/home/nipa/tmp");
ProcessBuilder ls = new ProcessBuilder()
		.command("ls")
		.directory(dir.toFile());
ProcessBuilder grepPdf = new ProcessBuilder()
		.command("grep", "pdf")
		.redirectOutput(Redirect.INHERIT);
List<Process> lsThenGrep = ProcessBuilder
		.startPipeline(List.of(ls, grepPdf));

// start an asynchronous computation
public static CompletableFuture<T> supplyAsync(
	Supplier<T>);

// attach further steps
public CompletableFuture<U> thenApply(Function<T, U>);
public CompletableFuture<U> thenCompose(
	Function<T, CompletableFuture<U>);
public CompletableFuture<Void> thenAccept(Consumer<T>);

// wait for the computation to finish and get result
public T join();

public void loadWebPage() {
	String url = "https://nipafx.dev";
	CompletableFuture<WebPage> future = CompletableFuture
			.supplyAsync(() -> webRequest(url))
			.thenApply(html -> new WebPage(url, html));
	// ... do other stuff
	WebPage page = future.join();
}

private String webRequest(String url) {
	// make request to URL and return HTML
	// (this can take a while)
}

// turn the error into a result
CompletableFuture<T> exceptionally(Function<Throwable, T>);
// turn the result or error into a new result
CompletableFuture<U> handle(BiFunction<T, Throwable, U>);

loadUser(id)
	.thenCompose(this::loadUserHistory)
	.thenCompose(this::createRecommendations)
	.exceptionally(ex -> {
		log.warn("Recommendation error", ex)
		return createDefaultRecommendations();
	})
	.thenAccept(this::respondWithRecommendations);

exceptionallyCompose(
	Function<Throwable, CompletionStage<T>>)

thenApplyAsync(Function<T, U>);
thenAcceptAsync(Consumer<T>);

CompletableFuture<T> exceptionallyAsync(
	Function<Throwable, T>)
CompletableFuture<T> exceptionallyComposeAsync(
	Function<Throwable, CompletableFuture<T>>)

Path.of(String); // ~ Paths.get(String) ⑪

Files.readString(Path); // ⑪
Files.writeString(Path, CharSequence, ...); // ⑪

Reader.transferTo(Writer); // ⑩
InputStream.transferTo(OutputStream); // ⑨

Reader.nullReader(); // ⑪
Writer.nullWriter(); // ⑪
InputStream.nullInputStream(); // ⑪
OutputStream.nullOutputStream(); // ⑪

Files.mismatch(Path, Path); // ⑫

FileSystems.newFileSystem(Path, ...); // ⑬

ByteBuffer.get(int, ...) // ⑬
ByteBuffer.put(int, ...) // ⑬

// in Java 14
StrictMath.decrementExact(int);
StrictMath.decrementExact(long);
StrictMath.incrementExact(int);
StrictMath.incrementExact(long);
StrictMath.negateExact(int);
StrictMath.negateExact(long);

// in Java 15
Math.absExact(int)
Math.absExact(long)
StrictMath.absExact(int)
StrictMath.absExact(long)

DateTimeFormatter.localizedBy(Locale);

Collection.toArray(IntFunction<T[]>);
Predicate.not(Predicate<T>); // static
Pattern.asMatchPredicate(); // ⇝ Predicate<String>

// instance version of String::format
String.formatted(Object... args);

Objects.checkIndex(long, long)
Objects.checkFromToIndex(long, long, long)
Objects.checkFromIndexSize(long, long, long)

List<String> list = [ "a", "b", "c" ];
Map<String, Integer> map = [ "one" = 1, "two" = 2 ];

List<String> list = List.of("a", "b", "c");
Map<String, Integer> mapImmediate = Map.of(
		"one", 1,
		"two", 2,
		"three", 3);
Map<String, Integer> mapEntries = Map.ofEntries(
		Map.entry("one", 1),
		Map.entry("two", 2),
		Map.entry("three", 3));

/* on List */ List<E> copyOf(Collection<E> coll);
/* on Set */ Set<E> copyOf(Collection<E> coll);
/* on Map */ Map<K, V> copyOf(Map<K,V> map);

public Customer(List<Order> orders) {
	this.orders = List.copyOf(orders);
}

HttpClient client = HttpClient.newBuilder()
	.version(HTTP_2)
	.connectTimeout(ofSeconds(5))
	.followRedirects(ALWAYS)
	.build();

HttpRequest request = HttpRequest.newBuilder()
	.GET()
	.uri(URI.create("https://nipafx.dev"))
	.setHeader("header-name", "header-value")
	.build();

// the generic `String`...
HttpResponse<String> response = client.send(
	request,
	// ... comes from this body handler ...
	BodyHandlers.ofString());
// ... and defines `body()`s return type
String body = response.body();

CompletableFuture<String> responseBody = client
	.sendAsync(request, BodyHandlers.ofString())
	.thenApply(this::logHeaders)
	.thenApply(HttpResponse::body);

Publisher<ByteBuffer> body = // ...
HttpRequest post = HttpRequest.newBuilder()
	.POST(BodyPublishers.fromPublisher(body))
	.build();
client.send(post, BodyHandlers.ofString())

Subscriber<String> body = // ...
HttpResponse<Void> response = client.send(
	request,
	BodyHandlers.fromLineSubscriber(subscriber));

void forEach (Consumer<StackFrame>);

public static void main(String[] args) { one(); }
static void one() { two(); }
static void two() {
	StackWalker.getInstance()
		.forEach(System.out::println);
}

// output
StackWalkingExample.two(StackWalking.java:14)
StackWalkingExample.one(StackWalking.java:11)
StackWalkingExample.main(StackWalking.java:10)

T walk (Function<Stream<StackFrame>, T>);

static void three() {
	String line = StackWalker.getInstance().walk(
		frames -> frames
			.filter(f -> f.getMethodName().contains("one"))
			.findFirst()
			.map(f -> "Line " + f.getLineNumber())
			.orElse("Unknown line");
	);
	System.out.println(line);
}

// output
Line 11

java.lang.NullPointerException
		at dev.nipafx.Regular.doing(Regular.java:28)
		at dev.nipafx.Business.its(Business.java:20)
		at dev.nipafx.Code.thing(Code.java:11)

java.lang.NullPointerException:
	Cannot invoke "String.length()" because the return
	value of "dev.nipafx.Irregular.doing()"
	is null
		at dev.nipafx.Regular.doing(Regular.java:28)
		at dev.nipafx.Business.its(Business.java:20)
		at dev.nipafx.Code.thing(Code.java:11)

java HelloJava11.java

java --source 11 hello-java-11

$ java -Xlog -version

# truncated a few messages
> [0.002s][info][os       ] HotSpot is running ...
# truncated a lot of messages

# "exactly gc" on "warning"
-Xlog:gc=warning
# "including gc" on "warning"
-Xlog:gc*=warning
# "exactly gc and os" on "debug"
-Xlog:gc+os=debug
# "gc" on "debug" and "os" on warning
-Xlog:gc=debug,os=warning

-Xlog       # the same as -Xlog:all
-Xlog:$TAG  # same as -Xlog:$TAG=info

# all debug messages into application.log
-Xlog:all=debug:file=application.log

# show uptime in ms and level
-Xlog:all:stdout:level,uptimemillis

-Xlog:$SELECTORS:$OUTPUT:$DECORATORS:$OUTPUT_OPTS

public class Main {

	public static void main(String[] args) {
		System.out.println(new Version().get());
	}

}

public class Version {

	public String get() { return "Java 8"; }

}

public class Version {

	public String get() { return "Java 9+"; }

}

└ dev
    └ nipafx ... (moar folders)
        ├ Main.class
        └ Version.class # 8
└ META-INF
    └ versions
        └ 9
            └ dev
                └ nipafx ... (moar folders)
                    └ Version.class # 9

public class SystemOutLogger implements Logger {

	public String getName() { return "SystemOut"; }

	public boolean isLoggable(Level level) { return true; }

	public void log(
			Level level, ResourceBundle bundle,
			String format, Object... params) {
		System.out.println(/* ...*/);
	}

	// another, similar `log` method

}

public class SystemOutLoggerFinder
		extends LoggerFinder {

	public Logger getLogger(
			String name, Module module) {
		return new SystemOutLogger();
	}

}

module system.out.logger {
    provides java.lang.System.LoggerFinder
        with system.out.logger.SystemOutLoggerFinder;
}

# possibly as root
java -Xshare:dump

$ java
	-Xshare:on
	# [... class path for app and deps ...]
	org.example.Main

$ java
	-XX:DumpLoadedClassList=classes.lst
	# [... class path for app and deps ...]
	org.example.Main

$ java
	-Xshare:dump
	-XX:SharedClassListFile=classes.lst
	-XX:SharedArchiveFile=app-cds.jsa
	# [... class path for app and deps ...]

$ java
	-XX:SharedArchiveFile=app-cds.jsa
	# [... class path for app and deps ...]
	org.example.Main

String method = generateString(size);

public String work() {
	return "Calling method \"" + method + "\"";
}

String s = greeting + ", " + place + "!";