5 More Advanced Java Tips That Senior Engineers Actually Use

// The CompletableFuture way: tasks are independent, cleanup is manual
CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> fetchUser(id));
CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() -> fetchOrders(id));
CompletableFuture<CreditScore> creditFuture = CompletableFuture.supplyAsync(() -> fetchCredit(id));

// If fetchOrders throws, fetchUser and fetchCredit keep running
// If we time out here, all three futures are still in flight somewhere
User user = userFuture.get(5, TimeUnit.SECONDS);
List<Order> orders = ordersFuture.get(5, TimeUnit.SECONDS);
CreditScore credit = creditFuture.get(5, TimeUnit.SECONDS);

// The structured way: all tasks share a lifetime, failure cancels siblings
UserProfile buildProfile(long id) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        Subtask<User> user = scope.fork(() -> fetchUser(id));
        Subtask<List<Order>> orders = scope.fork(() -> fetchOrders(id));
        Subtask<CreditScore> credit = scope.fork(() -> fetchCredit(id));

        scope.joinUntil(Instant.now().plusSeconds(5));
        scope.throwIfFailed();

        return new UserProfile(user.get(), orders.get(), credit.get());
    }
    // When scope closes: all tasks are guaranteed complete or cancelled.
    // If fetchOrders threw: fetchUser and fetchCredit get cancelled immediately.
    // If we hit the 5s deadline: everything cancels, no leaked work.
}

// First successful response wins, all others cancel
<T> T firstSuccess(List<Callable<T>> tasks) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnSuccess<T>()) {
        for (var task : tasks) scope.fork(task);
        scope.join();
        return scope.result();
    }
}

// Use case: query three replicas, take the fastest response
var result = firstSuccess(List.of(
    () -> queryReplica("us-east"),
    () -> queryReplica("eu-west"),
    () -> queryReplica("ap-south")
));

// Domain model: sealed hierarchy with nested records
sealed interface ShippingEvent permits Dispatched, InTransit, Delivered, Failed {}
record Dispatched(OrderId order, Warehouse origin) implements ShippingEvent {}
record InTransit(OrderId order, Location current, Carrier carrier) implements ShippingEvent {}
record Delivered(OrderId order, Location destination, Instant timestamp) implements ShippingEvent {}
record Failed(OrderId order, FailureReason reason) implements ShippingEvent {}

record OrderId(String value) {}
record Location(double lat, double lon) {}
record Warehouse(String code, Location location) {}
record Carrier(String name, String trackingUrl) {}
sealed interface FailureReason permits AddressInvalid, DamagedInTransit, CustomsHold {}
record AddressInvalid(String detail) implements FailureReason {}
record DamagedInTransit(String inspectionId) implements FailureReason {}
record CustomsHold(String referenceNumber) implements FailureReason {}

// Without record patterns: match the type, then extract fields manually
String describe(ShippingEvent event) {
    return switch (event) {
        case Failed f -> {
            if (f.reason() instanceof AddressInvalid a) {
                yield "Order " + f.order().value() + " failed: bad address — " + a.detail();
            } else if (f.reason() instanceof CustomsHold c) {
                yield "Order " + f.order().value() + " held at customs: " + c.referenceNumber();
            } else {
                yield "Order " + f.order().value() + " failed";
            }
        }
        default -> "...";
    };
}

// With record patterns: destructure the entire nested structure in one line
String describe(ShippingEvent event) {
    return switch (event) {
        case Dispatched(var id, Warehouse(var code, _))
            -> "Order " + id.value() + " dispatched from warehouse " + code;

        case InTransit(var id, Location(var lat, var lon), Carrier(var name, var url))
            -> "Order " + id.value() + " in transit at [" + lat + "," + lon + "] via " + name;

        case Delivered(var id, _, var time)
            -> "Order " + id.value() + " delivered at " + time;

        case Failed(var id, AddressInvalid(var detail))
            -> "Order " + id.value() + " failed: bad address — " + detail;

        case Failed(var id, DamagedInTransit(var inspectionId))
            -> "Order " + id.value() + " damaged, inspection: " + inspectionId;

        case Failed(var id, CustomsHold(var ref))
            -> "Order " + id.value() + " customs hold: " + ref;
    };
}

// Before Java 21: inconsistent, type-specific hacks
List<String> list = List.of("a", "b", "c");
String first = list.get(0);
String last = list.get(list.size() - 1);

LinkedHashSet<String> set = new LinkedHashSet<>(List.of("x", "y", "z"));
String firstOfSet = set.iterator().next();  // no better way
// last of set? iterate the whole thing

LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("alpha", 1); map.put("beta", 2); map.put("gamma", 3);
// first entry? map.entrySet().iterator().next()
// last entry? no clean way without iterating all entries

// Java 21+: uniform interface across List, LinkedHashSet, SortedSet, LinkedHashMap, etc.
SequencedCollection<String> list = List.of("a", "b", "c");
list.getFirst();    // "a"
list.getLast();     // "c"
list.reversed();    // reversed view: ["c", "b", "a"] — no copy, just a view

SequencedSet<String> set = new LinkedHashSet<>(List.of("x", "y", "z"));
set.getFirst();     // "x"
set.getLast();      // "z"
set.reversed();     // reversed view

SequencedMap<String, Integer> map = new LinkedHashMap<>();
map.put("alpha", 1); map.put("beta", 2); map.put("gamma", 3);
map.firstEntry();   // alpha=1
map.lastEntry();    // gamma=3
map.reversed();     // reversed view of the entire map

map.putFirst("zero", 0);   // insert at the beginning
map.putLast("delta", 4);   // insert at the end

// Practical example: processing the last N events from an ordered set
SequencedCollection<AuditEvent> events = getAuditLog();

// Five most recent events, no copy, no subList gymnastics
events.reversed().stream()
    .limit(5)
    .forEach(this::processEvent);

// Allocating and using off-heap memory safely
// Use case: building a high-performance buffer for network I/O

try (Arena arena = Arena.ofConfined()) {
    // Allocate 1MB of off-heap memory, automatically freed when arena closes
    MemorySegment buffer = arena.allocate(1_048_576);

    // Write structured data using layout-based access
    MemoryLayout layout = MemoryLayout.structLayout(
        ValueLayout.JAVA_INT.withName("id"),
        ValueLayout.JAVA_LONG.withName("timestamp"),
        ValueLayout.JAVA_DOUBLE.withName("value")
    );

    VarHandle idHandle = layout.varHandle(MemoryLayout.PathElement.groupElement("id"));
    VarHandle tsHandle = layout.varHandle(MemoryLayout.PathElement.groupElement("timestamp"));
    VarHandle valHandle = layout.varHandle(MemoryLayout.PathElement.groupElement("value"));

    idHandle.set(buffer, 0L, 42);
    tsHandle.set(buffer, 0L, System.nanoTime());
    valHandle.set(buffer, 0L, 3.14159);

    int id = (int) idHandle.get(buffer, 0L);          // 42
    double value = (double) valHandle.get(buffer, 0L); // 3.14159
}
// Arena closed: all off-heap memory is freed. No manual deallocation, no leaks.

// Calling a native C function from pure Java — no JNI, no C boilerplate
// Example: calling strlen from libc

Linker linker = Linker.nativeLinker();
SymbolLookup stdlib = linker.defaultLookup();

MethodHandle strlen = linker.downcallHandle(
    stdlib.find("strlen").orElseThrow(),
    FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
);

try (Arena arena = Arena.ofConfined()) {
    MemorySegment cString = arena.allocateFrom("Hello from Panama!");
    long length = (long) strlen.invoke(cString);  // 18
}

// Problem: batch a stream of events into groups of N for bulk processing
// Before Gatherers: ugly, stateful, breaks the stream paradigm

List<Event> events = getEvents();
List<List<Event>> batches = new ArrayList<>();
for (int i = 0; i < events.size(); i += 100) {
    batches.add(events.subList(i, Math.min(i + 100, events.size())));
}
batches.forEach(this::bulkInsert);

// With Gatherers: a clean intermediate operation inside the stream pipeline

events.stream()
    .gather(Gatherers.windowFixed(100))
    .forEach(this::bulkInsert);

// Custom gatherer: deduplicate consecutive elements
// [a, a, b, b, b, c, a, a] → [a, b, c, a]
static <T> Gatherer<T, ?, T> deduplicateConsecutive() {
    return Gatherer.ofSequential(
        // State: the last element seen
        () -> new Object[]{ null, Boolean.FALSE },  // [lastValue, initialized]
        // Integrator: emit only when the value changes
        (state, element, downstream) -> {
            if (!(boolean) state[1] || !Objects.equals(state[0], element)) {
                state[0] = element;
                state[1] = Boolean.TRUE;
                return downstream.push(element);
            }
            return true;
        }
    );
}

// Usage
List.of("a", "a", "b", "b", "b", "c", "a", "a")
    .stream()
    .gather(deduplicateConsecutive())
    .toList();
// Result: [a, b, c, a]

// Custom gatherer: emit a running average over a sliding window
static Gatherer<Double, ?, Double> movingAverage(int windowSize) {
    return Gatherer.ofSequential(
        () -> new ArrayDeque<Double>(windowSize),
        (window, element, downstream) -> {
            window.addLast(element);
            if (window.size() > windowSize) window.removeFirst();
            if (window.size() == windowSize) {
                double avg = window.stream().mapToDouble(Double::doubleValue).average().orElse(0);
                return downstream.push(avg);
            }
            return true;
        }
    );
}

// Usage: smooth noisy sensor data
sensorReadings.stream()
    .gather(movingAverage(10))
    .forEach(this::recordSmoothedReading);