language-java

Java

Records and sealed types

Modern Java models data without boilerplate.

record Point(double x, double y) {}

sealed interface Shape permits Circle, Rectangle {}
record Circle(Point center, double radius) implements Shape {}
record Rectangle(Point topLeft, Point bottomRight) implements Shape {}

• Use record for immutable data carriers — equals, hashCode, toString, and accessors for free.
• sealed closes a hierarchy; exhaustive switch replaces instanceof chains.

double area = switch (shape) {
    case Circle c    -> Math.PI * c.radius() * c.radius();
    case Rectangle r -> Math.abs(r.bottomRight().x() - r.topLeft().x())
                        * Math.abs(r.bottomRight().y() - r.topLeft().y());
};

Optional and null discipline

• Return Optional<T> from methods that may have no result; never use it as a field or parameter type.
• Optional is not a null check replacement — it signals "absence is a valid outcome."
• Annotate parameters and fields with @NonNull / @Nullable for static analysis.
• Jackson populates List<T> with literal nulls from valid JSON ({"content":[null]}) regardless of declared nullability — filter before mapping over an externally-deserialized collection, or drop them at the boundary with @JsonSetter(contentNulls = Nulls.SKIP).

Optional<User> find(String id) { ... }
find(id).map(User::email).orElseThrow(() -> new NotFoundException(id));

List<String> ids = payload.content().stream()
    .filter(Objects::nonNull)
    .map(Content::id)
    .toList();

Concurrency — virtual threads (JDK 21+)

Virtual threads (Project Loom) make blocking-style IO safe at scale.

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<User>  user  = scope.fork(() -> fetchUser(id));
    Future<Order> order = scope.fork(() -> fetchOrder(orderId));
    scope.join().throwIfFailed();
    return new Response(user.get(), order.get());
}

• Executors.newVirtualThreadPerTaskExecutor() — drop-in for newCachedThreadPool() with virtual-thread semantics.
• Do not pool virtual threads; create-per-task is the idiom.
• Watch for carrier-thread pinning: synchronized blocks and some native calls pin a virtual thread to its carrier. Prefer ReentrantLock when high-throughput blocking is expected.
• StructuredTaskScope (JDK 21–24 preview — not yet standard; enable with --enable-preview) enforces structured concurrency: tasks are joined before the scope exits.