Java on Roman Empire

JUnit 5

contact@romanempire.dev (Roman) — Fri, 20 Mar 2026 00:00:00 +0000

Foundations
#

JUnit 5 is composed of three modules:

Module	Role
JUnit Platform	Foundation layer. Defines the `TestEngine` API and launches test suites. IDEs and build tools (Maven, Gradle) integrate here.
JUnit Jupiter	The JUnit 5 programming model. Provides all the annotations (`@Test`, `@BeforeEach`, etc.) and the engine that runs them.
JUnit Vintage	Backwards compatibility engine. Runs JUnit 3 and JUnit 4 tests on the Platform without changes.

Java 25 (LTS)

contact@romanempire.dev (Roman) — Wed, 18 Mar 2026 00:00:00 +0000

This covers most of the major language changes from Java 21 (the last LTS) through Java 25.

Unnamed Variables & Patterns
#

JEP 456 - Java 22

Use _ for variables and patterns that are intentionally unused. Clarifies intent and suppresses IDE warnings about unused bindings.

// Unused loop variable
for (Order _ : orders)
    total++;

// Unused lambda parameter
map.forEach((_, value) -> process(value));

// Unused exception binding
try {
    return Integer.parseInt(s);
} catch (NumberFormatException _) {
    return 0;
}

// Pattern matching - unnamed pattern variable
if (obj instanceof Point(int x, _)) {
    System.out.println("x = " + x);
}

// Multiple patterns in one case when no variables are bound
switch (shape) {
    case Circle _, Square _ -> System.out.println("basic shape");
}

Compact Source Files & Instance Main Methods
#

JEP 512

Java 21 (LTS)

contact@romanempire.dev (Roman) — Tue, 17 Mar 2026 00:00:00 +0000

This covers most of the major language changes from Java 17 (the last LTS) through Java 21.

Runnable
#

java.lang.Runnable is a functional interface with a single method: void run(). It represents a task, the what, separate from the thread that executes it.

In functional programming terms, Runnable is a deferred effect no inputs, no return value, not executed at the point of definition. The lambda body is just captured; execution is deferred until something calls run().

Java 17 (LTS)

contact@romanempire.dev (Roman) — Sun, 15 Mar 2026 00:00:00 +0000

This covers most of the major language changes from Java 11 (the last LTS) through Java 17.

Records
#

JEP 395 - java.lang.Record

Records are a concise way to declare data carrier classes. They are transparent, immutable, and remove the boilerplate of writing constructors, getters, equals, hashCode, and toString manually.

record Point(int x, int y) {}

// Equivalent to a class with:
// - private final int x, y
// - public int x(), int y()
// - equals(), hashCode(), toString()

The compiler auto-generates for each component:

Java 11 (LTS)

contact@romanempire.dev (Roman) — Sat, 14 Mar 2026 00:00:00 +0000

This covers most of the major language changes from Java 8 (the last LTS) through Java 11.

String Methods
#

java.lang.String

New methods added to String in Java 11:

Return Type	Method	Description
`boolean`	`isBlank()`	`true` if empty or contains only whitespace
`Stream<String>`	`lines()`	Splits into a stream of lines by line terminators
`String`	`strip()`	Removes leading and trailing whitespace (Unicode-aware)
`String`	`stripLeading()`	Removes leading whitespace
`String`	`stripTrailing()`	Removes trailing whitespace
`String`	`repeat(int count)`	Repeats the string `count` times

"  hello  ".strip();         // "hello"
"  hello  ".stripLeading();  // "hello  "
"  hello  ".stripTrailing(); // "  hello"
"  ".isBlank();              // true
"ha".repeat(3);              // "hahaha"

// lines() - splits by \n, \r, or \r\n
"one\ntwo\nthree"
        .lines()
        .collect(Collectors.toList());
// [one, two, three]

trim() vs strip() trim - Was intriduced before Unicode was finished strip - is Unicode aware

Java 8 (LTS)

contact@romanempire.dev (Roman) — Sat, 21 Feb 2026 00:00:00 +0000

Lambda
#

An anonymous function that can be stored in a variable or passed as an argument. Syntax: parameters -> body.

x -> x - 1                  // single param, expression body
(x, y) -> x - y             // multiple parameters
(x, y) -> { return x - y; } // block body

// Passed as an argument to forEach
List<Integer> nums = Arrays.asList(42, 300, 90000);
nums.forEach(n -> System.out.println(n));

Functional Interfaces
#

java.util.function

Java on Roman Empire

JUnit 5

Foundations #

Java 25 (LTS)

Unnamed Variables & Patterns #

Compact Source Files & Instance Main Methods #