Java 25

// option A
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// option B
import java.util.*;

import module $mod;

import module $mod;

import module java.base;
import module java.desktop;
import module java.sql;

public class Example {

	public void example() {
		// error: reference to Date is ambiguous
		var outdated = new Date(1997, 1, 18);
		// error: reference to List is ambiguous
		var letters = List.of("I", "J", "N");
	}

}

import module java.base;
import module java.desktop;
import module java.sql;

import java.util.Date;
import java.util.List;

public class Example {

	public void example() {
		var outdated = new Date(1997, 1, 18);
		var letters = List.of("I", "J", "N");
	}

}

// complete Main.java - no explicit imports!
void main() {
	List<?> dates = Stream
		.of(1, 2, 23, 29)
		.map(BigDecimal::new)
		.map(day -> LocalDate.of(
			2024,
			RandomGenerator.getDefault()
				.nextInt(11) + 1,
			day.intValue()))
		.toList();

	IO.println(dates);
}

// smallest viable Main.java
void main() {
	// ...
}

void main() {
	var name = IO.readln("Please enter your name: ");
	IO.println("Nice to meet you, " + name);
}

// complete Main.java - no explicit imports!
void main() {
	List<?> dates = Stream
		.of(1, 2, 23, 29)
		.map(BigDecimal::new)
		.map(day -> LocalDate.of(
			2024,
			RandomGenerator.getDefault()
				.nextInt(11) + 1,
			day.intValue()))
		.toList();

	IO.println(dates);
}

java Main.java

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

java -cp 'Lib/*' Main.java

class Name {

	protected final String first, last;

	Name(String first, String last) {
		// [... checks, assignments, etc. ...]
	}

	Name(String fst, String mid, String lst) {
		this(fst + " " + mid, lst);
	}
}

class ThreePartName extends Name {

	protected final String middle;

	ThreePartName(String fst, String mid, String lst) {
		// doesn't compile without this call
		super(fst, lst);
		this.middle = mid;
	}
}

Name(String first, String last) {
	this.first = first;
	this.last = last;
	IO.println(this);
}

ThreePartName(String fst, String mid, String lst) {
	super(fst, lst);
	this.middle = mid;
}

new ThreePartName("Jane", "Jennifer", "Doe");
// prints: "Jane null Doe" 😖

class Name {

	protected final String first;
	protected final String last;

	Name(String first, String last) {
		this.first = first;
		this.last = last;
	}

	Name(String full) {
		// does the same work twice
		this(full.split(" ")[0], full.split(" ")[1]);
	}

}

class Name {

	// [... fields, constructor as before ...]

	Name(String full) {
		String[] names = full.split(" ");
		this(names[0], names[1]);
	}

}

Constructor(...) {
	// prologue
	// call to this(...) or super(...)
	// epilogue
}

class ThreePartName extends Name {

	protected final String middle;

	ThreePartName(String fst, String mid, String lst) {
		// can't have a middle name without a first name
		requireNonNullNonEmpty(fst);
		this.middle = mid;
		super(fst, lst);
	}

}

class ThreePartName extends Name {

	protected final String middle;

	ThreePartName(String fst, String mid, String lst) {
		this.middle = mid;
		// shorten first if middle is given
		var shortFst = mid.length() == 1
				? fst.substring(0, 1)
				: fst;
		super(shortFst, lst);
	}

}

class ThreePartName extends Name {

	protected final String middle;

	ThreePartName(String full) {
		// split "first middle last" on space (once 🙌🏾)
		var names = full.split(" ");
		this.middle = names[1];
		super(names[0], names[2]);
	}

}

static final ThreadLocal<Integer> ANSWER =
	new ThreadLocal<>();

void main() {
	ANSWER.set(42);
	IO.println(ANSWER.get());     // "42"
	new Thread(() -> {
		IO.println(ANSWER.get()); // "null"
	}).start();
	IO.println(ANSWER.get());     // "42"
}

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
}

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

void a() {
	ScopedValue
		.where(ANSWER, 42)
		.run(this::b);
}

void b() {
	IO.println(ANSWER.get()); // "42"
	ScopedValue
		.where(ANSWER, ANSWER.get() + 1)
		.run(this::c);
	IO.println(ANSWER.get()); // "42"
}

void c() {
	IO.println(ANSWER.get()); // "43"
}

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"        //      │
}                                           // ─────┘

# training run (⇝ profile)
$ java -XX:AOTMode=record
       -XX:AOTConfiguration=app.aotconf
       -cp app.jar com.example.App ...
# assembly phase (profile ⇝ AOTCache)
$ java -XX:AOTMode=create
       -XX:AOTConfiguration=app.aotconf
       -XX:AOTCache=app.aot
       -cp app.jar
# production run (AOTCache ⇝ performance)
$ java -XX:AOTCache=app.aot
       -cp app.jar com.example.App ...

# 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 ...

95-64 .........................HHHHHHH
63-32 HHHHHHHHHHHHHHHHHHHHHHHH.AAAA.TT
31- 0 CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC

63-32 CCCCCCCCCCCCCCCCCCCCCCHHHHHHHHHH
31- 0 HHHHHHHHHHHHHHHHHHHHHVVVVAAAASTT

-XX:+UseCompactObjectHeaders

static <T> Gatherer<T, ?, T> transparent() {
	Integrator<Void, T, T> integrator = (_, el, ds)
		-> ds.push(el);
	return Gatherer.of(integrator);
}

static <T, R> Gatherer<T, ?, R> map(Function<T, R> f) {
	Integrator<Void, T, R> integrator = (_, el, ds) -> {
		R newEl = f.apply(el);
		return ds.push(newEl);
	};
	return Gatherer.of(integrator);
}

Supplier<List<T>> initializer = ArrayList::new;

Integrator<List<T>, T, List<T>> integrator =
	(list, el, ds) -> {
		list.add(el);

		if (list.size() < size)
			return true;
		else {
			var group = List.copyOf(list);
			list.clear();
			return ds.push(group);
		}
	};

BiConsumer<List<T>, Downstream<List<T>>> finisher =
	(list, ds) -> {
		var group = List.copyOf(list);
		ds.push(group);
	};

static <T> Gatherer<T, ?, List<T>> groups(int size) {
	Supplier<...> initializer = // ...
	Integrator<...> integrator = // ...
	BiConsumer<...> finisher = // ...

	return Gatherer.ofSequential(
		initializer, integrator, finisher);
}

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

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

/**md
 *
 * Markdown here...
 *
 */

/**md
 *
 * Here's a list:
 *
    * item #1
    * item #1
 *
 */

/**md
 *
 * ```java
 * /* a Java inline comment */
 * ```
 *
 */

/// - the module [java.base/]
/// - the package [java.util]
/// - the class [String]
/// - the field [String#CASE_INSENSITIVE_ORDER]
/// - the method [String#chars()]

/// - [the _java.base_ module][java.base/]
/// - [the `java.util` package][java.util]
/// - [the `String` class][String]
/// - [the `String#CASE_INSENSITIVE_ORDER` field][String#CASE_INSENSITIVE_ORDER]
/// - [the `String#chars()` method][String#chars()]

/// For more information on comments,
/// see {@jls 3.7 Comments}.
///
/// @implSpec this implementation does _nothing_
public void doSomething() { }

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

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

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

public sealed interface Page
	permits GitHubIssuePage, GitHubPrPage,
			ExternalPage, ErrorPage {
	// ...
}

public Category categorize(Page page) {
	return switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		case ExternalPage ext -> categorizeExternal(ext);
		case ErrorPage err -> categorizeError(err);
	}
}

public Category categorize(Page page) {
	return switch (page) {
		// categorize only GitHub pages
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		// return Category.NONE for other page types
	}
}

public Category categorize(Page page) {
	return switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		default -> Category.NONE;
	}
}

public Category categorize(Page page) {
	return switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		// `GitHubCommitPage` gets no category!
		default -> Category.NONE;
	}
}

public Category categorize(Page page) {
	return switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		// duplication 😢
		case ErrorPage err -> Category.NONE;
		case ExternalPage ext -> Category.NONE;
	};
}

public Category categorize(Page page) {
	// error:
	//     "the switch expression does not cover
	//      all possible input values"
	return switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		case ErrorPage err -> Category.NONE;
		case ExternalPage ext -> Category.NONE;
	}
}

public Category categorize(Page page) {
	return switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		case ErrorPage err, ExternalPage ext
			-> Category.NONE;
	};
}

public Category categorize(Page page) {
	return switch (page) {
		case GitHubIssuePage is -> categorizeIssue(is);
		case GitHubPrPage pr -> categorizePr(pr);
		case ErrorPage _, ExternalPage _
			-> Category.NONE;
	};
}

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

String[] javaStrings = { "mouse", "cat", "dog" };
// Arena offHeap = ...

MemorySegment pointers = offHeap.allocateArray(
	ValueLayout.ADDRESS, javaStrings.length);
for (int i = 0; i < javaStrings.length; i++) {
	// allocate off-heap & store a pointer
	MemorySegment cString = offHeap
		.allocateUtf8String(javaStrings[i]);
	pointers
		.setAtIndex(ValueLayout.ADDRESS, i, cString);
}

// String[] javaStrings = ...
// MemorySegment pointers =

for (int i = 0; i < javaStrings.length; i++) {
	MemorySegment cString = pointers
		.getAtIndex(ValueLayout.ADDRESS, i);
	javaStrings[i] = cString.getUtf8String(0);
}

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

String[] javaStrings = { "mouse", "cat", "dog" };
try (Arena offHeap = Arena.ofConfined()) {
	// [move Java strings off heap]
	// invoke foreign function
	radixSort.invoke(
		pointers, javaStrings.length,
		MemorySegment.NULL, '\0');
	// [copy data back to heap]
}

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_216;
if (x instanceof float f)
	// use `f`

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

String property = "last_name";
String value = "Doe";

// concatenation
String query =
	"SELECT * FROM Person p WHERE p."
		+ property + " = '" + value + "'";
// formatting
String query =
	"SELECT * FROM Person p WHERE p.%s = '%s'"
		.formatted(property, value);

// (fictional syntax!)
String query =
	"SELECT * FROM Person p "
		+ "WHERE p.\{property} = '\{value}'";

Statement query = SQL."""
	SELECT * FROM Person p
	WHERE p.\{property} = '\{value}'
	""";

// implicitly short-circuits on error
try (var scope = StructuredTaskScope.open()) {
	// spawns new (virtual) threads
	var subtaskA = scope.fork(this::taskA);
	var subtaskB = scope.fork(this::taskB);

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

	return subtaskA.get() + subtaskB.get();
} catch (ExecutionException ex) {
	// TODO: handle task errors
} // waits until all tasks/threads complete

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

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

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

interface Joiner<T, R> {

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

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

	R result() throws Throwable;

}

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 = // ...

PEMEncoder pe = PEMEncoder.of();
String pem = pe.encodeToString(cert);

PEMDecoder pd = PEMDecoder.of();
DEREncodable cert2 = pd.decode(pem);

var pd = PEMDecoder.of().withEncryption(pass);