Java 21 💣💥

public class PageTreeFactory {

	public static Page loadPageTree(/*...*/) {
		// [...]
	}

}

public void categorize(Page page) {
	if (page instanceof GitHubIssuePage) {
		GitHubIssuePage issue = (GitHubIssuePage) page;
		categorizeIssuePage(issue);
	} else if (page instanceof GitHubPrPage) {
		// ... etc. for all types
	}
}

public void categorize(Page page) {
	if (page instanceof GitHubIssuePage issue)
		categorizeIssuePage(issue);
	else if (page instanceof GitHubPrPage pr)
		// ... etc. for all types
}

record ExternalPage(URI url, String content) { }

if (page instanceof
		ExternalPage(var url, var content)) {
	// use `url` and `content`
}

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage issue
			-> categorizeIssuePage(issue);
		case ExternalPage(var url, var content)
			-> categorizeExternalUrl(url);
		// ... etc. for all types
	}
}

error: the switch expression does not cover
       all possible input values

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage issue ->
			categorizeIssuePage(issue);
		// ... etc. for all types
		default ->
			throw new IllegalArgumentException();
	}
}

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

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage issue -> // ...
		case GitHubPrPage pr -> // ...
		case ExternalPage external -> // ...
		case ErrorPage error -> // ...
	}
}

record GitHubCommitPage(/*…*/) implements Page {

	// ...

}

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

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage issue -> // ...
		case GitHubPrPage pr -> // ...
		case ExternalPage external -> // ...
		case ErrorPage error -> // ...
		// missing case
	}
}

record PageWithLinks(Page page, Set<URI> links) {

	PageWithLinks {
		requireNonNull(page);
		requireNonNull(links);
		links = new HashSet<>(links);
	}

}

Match<User> findUser(String userName) { ... }

// types
sealed interface Match<T> { }

record None<T>() implements Match<T> { }

record Exact<T>(T entity) implements Match<T> { }

record Fuzzies<T>(Collection<T> entities)
	implements Match<T> { }

// calling the method
switch (findUser("John Doe")) {
	case None<> none -> // ...
	case Exact<> exact -> // ...
	case Fuzzies<> fuzzies -> // ...
}

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage(_, _, int issue, _) -> // ...
		case GitHubPrPage(_, _, int pr, _) -> // ...
		case ExternalPage(var url, _) -> // ...
		case ErrorPage(var url, _) -> // ...
	}
}

public void categorizeGitHub(Page page) {
	switch (page) {
		case GitHubIssuePage(_, _, int issue, _) -> // ...
		case GitHubPrPage(_, _, int pr, _) -> // ...
		case ErrorPage _, ExternalPage _ -> { };
	};
}

public record ErrorPage(
	URI url, Exception ex) { }

public record ExternalPage(
	URI url, String content) { }

public record GitHubIssuePage(
	URI url, String content,
	int issueNumber, Set<Page> links) { }

public record GitHubPrPage(
	URI url, String content,
	int prNumber, Set<Page> links) { }

public sealed interface Page
		permits ErrorPage, SuccessfulPage {
	URI url();
}

public sealed interface SuccessfulPage
		extends Page permits ExternalPage, GitHubPage {
	String content();
}

public sealed interface GitHubPage
		extends SuccessfulPage
		permits GitHubIssuePage, GitHubPrPage {
	Set<Page> links();
	default Stream<Page> subtree() { ... }
}

record ExternalPage(URI url, String content) {
	// compact constructor
	ExternalPage {
		Objects.requireNonNull(url);
		Objects.requireNonNull(content);
		if (content.isBlank())
			throw new IllegalArgumentException();
	}
}

// compact constructor
GitHubPrPage {
	// [...]
	links = Set.copyOf(links);
}

public record GitHubIssuePage(
		URI url, String content,
		int issueNumber, Set<Page> links) {

	public String toPrettyString() {
		return "🐈 ISSUE #" + issueNumber;
	}

}

private static String toPrettyString(Page page) {
	return switch (page) {
		case ErrorPage(var url, _)
			-> "💥 ERROR: " + url.getHost();
		case ExternalPage(var url, _)
			-> "💤 EXTERNAL: " + url.getHost();
		case GitHubIssuePage(_, _, int issueNumber, _)
			-> "🐈 ISSUE #" + issueNumber;
		case GitHubPrPage(_, _, int prNumber, _)
			-> "🐙 PR #" + prNumber;
	};
}

try (var executor = Executors
		.newVirtualThreadPerTaskExecutor()) {
	for (int i = 0; i < 1_000_000; i++) {
		var number = i;
		executor.submit(() -> {
			Thread.sleep(Duration.ofSeconds(1));
			return number;
		});
	}
} // executor.close() is called implicitly, and waits

spring.threads.virtual.enabled=true

@GET
@Path("api")
@RunOnVirtualThread
public String handle() {
	// ...
}

// limits concurrent queries but pools 👎🏾
private static final ExecutorService DB_POOL =
	Executors.newFixedThreadPool(16);

public <T> Future<T> queryDatabase(Callable<T> query) {
	return DB_POOL.submit(query);
}

// limits concurrent queries without pool 👍🏾
private static final Semaphore DB_SEMAPHORE =
	new Semaphore(16);

public <T> T queryDatabase(Callable<T> query)
		throws Exception {
	DB_SEMAPHORE.acquire();
	try {
		return query.call();
	} finally {
		DB_SEMAPHORE.release();
	}
}

// guarantees sequential access, but pins (for now) 👎🏾
public synchronized String accessResource() {
	return access();
}

// guarantees sequential access without pinning 👍🏾
private static final ReentrantLock LOCK =
	new ReentrantLock();

public String accessResource() {
	// lock guarantees sequential access
	LOCK.lock();
	try {
		return access();
	} finally {
		LOCK.unlock();
	}
}

// copies value for each inheriting thread 👎🏾
static final ThreadLocal<Principal> PRINCIPAL =
	new ThreadLocal<>();

public void serve(Request request, Response response) {
	var level = request.isAdmin() ? ADMIN : GUEST;
	var principal = new Principal(level);
	PRINCIPAL.set(principal);
	Application.handle(request, response);
}

// immutable, so no copies needed 👍🏾
static final ScopedValue<Principal> PRINCIPAL =
	new ScopedValue<>();

public void serve(Request request, Response response) {
	var level = request.isAdmin() ? ADMIN : GUEST;
	var principal = new Principal(level);
	ScopedValue
		.where(PRINCIPAL, principal)
		.run(() -> Application
			.handle(request, response));
}

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}'";

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

String form = STR."""
	Desc     Unit   Qty   Amount
	\{desc} $\{price} \{qty} $\{price * qty}

	Subtotal  $\{price * qty}
	Tax       $\{price * qty * tax}
	Total     $\{price * qty * (1.0 + tax)}
	""";

Desc     Unit   Qty   Amount
hammer   $7.88  3     $23.64

Subtotal  $23.64
Tax       $3.546
Total     $27.186

String form = FMT."""
	Desc        Unit      Qty   Amount
	%-10s\{desc} $%5.2f\{price} %5d\{qty} $%5.2f\{price * qty}

	Subtotal  $%5.2f\{price * qty}
	Tax       $%5.2f\{price * qty * tax}
	Total     $%5.2f\{price * qty * (1.0 + tax)}
	""";

Desc        Unit      Qty   Amount
hammer      $ 7.88      3   $23.64

Subtotal  $23.64
Tax       $ 3.55
Total     $27.19

public interface Processor<RESULT, EX> {
	RESULT process(StringTemplate s) throws EX;
}

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

// validates & escapes JSON
JSONObject doc = JSON."""
	{
		"name": "\{name}",
		"year": "\{bday.getYear()}"
	}
	""";

for (E element : list.reversed())
	// ...

sortedSet
	.reversed().stream()
	//...

deque.reversed().toArray();

var letters = new ArrayList<>(List.of("A", "B", "C"));
	// ⇝ letters = ["A", "B", "C"]
letters.reversed().removeFirst();
	// ⇝ letters = ["A", "B"]

void addFirst(E);
void addLast(E);
E getFirst();
E getLast();
E removeFirst();
E removeLast();

SequencedCollection<E> reversed();

SortedSet<String> letters = new TreeSet<>(
	List.of("B", "A", "C"));
	// ⇝ letters = ["A", "B", "C"]
letters.addLast("D");

// registered as a service
public abstract class InetAddressResolverProvider {
	InetAddressResolver get(Configuration config);
	String name();
}

public interface InetAddressResolver {
	Stream<InetAddress> lookupByName(
		String host, LookupPolicy lookupPolicy);
	String lookupByAddress(byte[] addr);
}

// in module declaration
provides InetAddressResolverProvider
	with TransparentInetAddressResolverProvider;

// class
public class TransparentInetAddressResolverProvider
		extends InetAddressResolverProvider {

	@Override
	public InetAddressResolver get(
			Configuration config) {
		return new TransparentInetAddressResolver(
			config.builtinResolver());
	}

}

public class TransparentInetAddressResolver
		implements InetAddressResolver {

	private InetAddressResolver builtinResolver;

	public TransparentInetAddressResolver(
			InetAddressResolver builtinResolver) {
		this.builtinResolver = builtinResolver;
	}

	// ...

}

@Override
public Stream<InetAddress> lookupByName(
		String host, LookupPolicy lookupPolicy) {
	return builtinResolver
		.lookupByName(host, lookupPolicy);
}

@Override
public String lookupByAddress(byte[] addr) {
	return builtinResolver.lookupByAddress(addr);
}

"String".indexOf(
	String str, int beginIndex, int endIndex)

var now = ZonedDateTime.now();
for (var locale : List.of(
		Locale.of("en", "US"),
		Locale.of("be", "BE"),
		Locale.of("vi", "VN"))) {
	Locale.setDefault(locale);

	var custom = DateTimeFormatter
		.ofPattern("y-MM-dd");
	var local = DateTimeFormatter
		.ofLocalizedDate(FormatStyle.SHORT);
	var customLocal = DateTimeFormatter
		.ofLocalizedPattern("yMM");

	// pretty print
}

DateTimeFormatterBuilder appendLocalized(
	String requestedTemplate);

static String getLocalizedDateTimePattern(
	String requestedTemplate,
	Chronology chrono, Locale locale)

enum State {
	RUNNING, SUCCESS, FAILED, CANCELLED
}

public class Main {
	public static void main(String[] args) {
		System.out.println("Hello, World!");
	}
}

java Prog.java

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

java -cp 'Lib/*' Prog.java