Java 26

class ThreePartName extends Name {
	private final String middle;

	ThreePartName(String full) {
		// split "first middle last" on space
		var names = full.split(" ");
		// assign fields before `super`
		this.middle = names[1];
		// call `Name(String first, String last)`
		super(names[0], names[2]);
	}
}

BiConsumer<String, Double> = (s, _) -> // use `s`

Object obj = // ...
if (obj instanceof User(var name, _))
	// use `name`

switch (obj) {
	case User _ -> userCount++;
	case Admin _ -> adminCount++;
}

import module $mod;

// entire source file
// implicit `import module java.base`
void main() {
    var name = IO.readln("Please enter your name: ");
    IO.println("Nice to meet you, " + name);
}

Stream.of("A", "C", "F", "B", "S")
	.gather(groups(2))
	.forEach(IO::println);

// [A, C]
// [F, B]
// [S]

static final ScopedValue<Integer> ANSWER =
	ScopedValue.newInstance();

void main() {
	ScopedValue //      ⬐ VALUE
		.where(ANSWER, 42)
		//  |<---------- SCOPE ----------->|
		.run(() -> IO.println(ANSWER.get())); // "42"

	// OUT OF SCOPE
	ANSWER.get(); // ⚡️ NoSuchElementException
}

// create `Arena` to manage off-heap memory lifetime
try (Arena offHeap = Arena.ofConfined()) {
	// [allocate off-heap memory to store pointers]
	// [do something with off-heap data]
	// [copy data back to heap]
} // off-heap memory is deallocated here

// find foreign function on the C library path
Linker linker = Linker.nativeLinker();
SymbolLookup stdlib = linker.defaultLookup();
MethodHandle radixSort = linker
	.downcallHandle(stdlib.find("radixsort"), ...);

MyFirstJava
 ├─ Main.java
 ├─ Helper.java
 └─ Lib
     └─ library.jar

java -cp 'Lib/*' Main.java

# training run (⇝ AOTCache)
$ java -XX:AOTCacheOutput=app.aot
       -cp app.jar com.example.App ...
# production run (AOTCache ⇝ performance)
$ java -XX:AOTCache=app.aot
       -cp app.jar com.example.App ...

-XX:+UseCompactObjectHeaders

/// Returns `true` if, and only if,
/// [#length()] is `0`.
///
/// @return `true` if [#length()] is `0`,
//          otherwse `false`
/// @since 1.6
@Override
public boolean isEmpty() { /* ... */ }

int x = 0;
if (x instanceof byte b)
	IO.println(b + " in [-128, 127]");
else
	IO.println(x + " not in [-128, 127]");

int x = 16_777_217;
if (x instanceof float f)
	// use `f`

Boolean bool = // ...
var emoji = switch (bool) {
	case null -> "";
	case true -> "✅";
	case false -> "❌";
}

private volatile LoginService login;

private LoginService getLogin() {
	var login = this.login;
	if (login == null) {
		synchronized (this) {
			login = this.login;
			if (login == null)
				this.login = login =
					LoginService.initialize();
		}
	}
	return login;
}

public class UserController {

	private final LazyConstant<LoginService> login;

	public UserController() {
		this.login = LazyConstant
			.of(LoginService::initialize);
		// using `login` later...
		IO.println(login.get());
	}

}

var list = List.ofLazy(2, index -> "" + index);
var map = Map.ofLazy(Set.of(0, 1), key -> "" + key);

HttpClient client = HttpClient.newBuilder()
	.version(HTTP_2)
	.build();

HttpRequest request = HttpRequest.newBuilder()
	.uri(URI.create("https://dev.java"))
	.build();

var response = client
	.send(request, BodyHandlers.ofString());

HttpClient client = HttpClient.newBuilder()
	.version(HTTP_3)
	.build();

HttpRequest request = HttpRequest.newBuilder()
	.uri(URI.create("https://dev.java"))
	.version(HTTP_3)
	.build();

// implicitly short-circuits on error
try (var scope = StructuredTaskScope.open()) {
	// spawns new (virtual) threads
	Subtask<String> a = scope.fork(this::taskA);
	Subtast<String> b = scope.fork(this::taskB);

	// waits explicitly for success
	// (throws error if there was one)
	scope.join();

	return a.get() + b.get();
} catch (FailedException ex) {
	// TODO: handle task errors
} // waits until all tasks/threads complete

try (var scope = StructuredTaskScope.open(
		Joiner.awaitAll())) {
	var subtask = scope.fork(this::task);
	// never throws:
	scope.join();
	switch (subtask.state()) {
		case SUCCESS -> // ...
		case FAILED -> // ...
		case UNAVAILABLE -> // ...
	}
} catch (FailedException ex) {
	// TODO: handle task errors
}

try (var scope = StructuredTaskScope.open(
		Joiner.<String> anySuccessfulOrThrow())) {
	// no need to grab the `Subtask` instances
	scope.fork(this::taskA);
	scope.fork(this::taskB);

	// returns the first successful result
	return scope.join();
} catch (FailedException ex) {
	// TODO: handle task errors
}

interface Joiner<T, R> {

	boolean onFork(Subtask<? extends T> subtask);

	boolean onComplete(Subtask<? extends T> subtask);

	void onTimeout();

	R result() throws Throwable;

}

var timeout = Duration.ofSeconds(3);
try (var scope = StructuredTaskScope.open(
		Joiner.<String> anySuccessfulOrThrow(),
		cfg -> cfg.withTimeout(timeout))) {
	// [... forks ...]

	// throws when timeout expires
	return scope.join();
} catch (TimeoutException ex) {
	// TODO: handle timeout
} catch (FailedException ex) {
	// TODO: handle task errors
}

ScopedValue.where(ANSWER, 42).run(() -> {// scope ──┐
	try (var scope = StructuredTaskScope    //      │
			.open() {                       //      │
		               // child threads' scope ──┐  │
		var subA = scope.fork(ANSWER::get); //   │  │
		var subB = scope.fork(ANSWER::get); //   │  │
		                                    //   │  │
		scope.join();                       //   │  │
		                                    //   │  │
		var result = subA.get()+subB.get(); //   │  │
		IO.println(result);  // "84"        //   │  │
	}           // all child threads completed ──┘  │
	IO.println(ANSWER.get()) // "42"        //      │
}                                           // ─────┘

-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj
0DAQcDQgAEi/kRGOL7wCPTN4KJ
2ppeSt5UYB6ucPjjuKDtFTXbgu
OIFDdZ65O/8HTUqS/sVzRF+dg7
H3/tkQ/36KdtuADbwQ==
-----END PUBLIC KEY-----

X509Certificate cert = // ...

// encode
PEMEncoder encoder = PEMEncoder.of();
String pem = encoder.encodeToString(cert);

// decode
PEMDecoder decoder = PEMDecoder.of();
DEREncodable cert2 = decoder.decode(pem);

assert cert.equals(cert2);

PrivateKey key = // ...
char[] pass = // ...

String pem = encoder
	.withEncryption(pass)
	.encodeToString(key);
DEREncodable der = decoder
	.withDecryption(pass)
	.decode(pem);