Advanced Java

Advanced Java is less about memorizing APIs and more about controlling contracts under real conditions: concurrent callers, immutable data, asynchronous work, cancellation, timeouts and resource ownership. Start with a clear correctness model, then choose the smallest tool that enforces it.

Immutability as a Concurrency Tool

An immutable value cannot change after construction, so callers may share it without locks. Records are ideal for simple data carriers, while defensive copies protect mutable collections or arrays exposed by an API.

Executor Ownership

Prefer ExecutorService or structured application-managed executors over creating an uncontrolled thread per task. An executor makes concurrency limits, shutdown behavior and task queues explicit and testable.

CompletableFuture Composition

CompletableFuture models a value that will arrive later. thenApply transforms a completed result, thenCompose chains another asynchronous operation and exceptionally or handle defines an error policy without blocking the caller unnecessarily.

Synchronization and Atomicity

A read-modify-write action such as count++ is not atomic. Use synchronized, AtomicInteger or a higher-level concurrent structure based on the operation; visibility and compound updates must both be correct.

Timeouts and Cancellation

A timeout is part of a service contract, not an afterthought. Define what is cancelled, what work may continue, how callers observe the timeout and how resources are released when a request stops waiting.

Worked Examples

Example 1: Use a Record for Immutable Data

A record declares final components, accessors, equals, hashCode and toString. It is a concise and reliable option for a value object whose identity is its data.

Code

public class Main {
    record Deployment(String service, String version) { }

    public static void main(String[] args) {
        Deployment release = new Deployment("api", "2.4.0");
        System.out.println(release.service());
        System.out.println(release.version());
    }
}

Expected Result

api
2.4.0

Example 2: Run Bounded Tasks With an Executor

A fixed thread pool limits concurrent work. The caller submits a Callable, waits for its Future result and shuts down the executor when the owned work is complete.

Code

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        try {
            Future<Integer> result = executor.submit(() -> 21 * 2);
            System.out.println(result.get());
        } finally {
            executor.shutdown();
        }
    }
}

Expected Result

Example 3: Compose an Asynchronous Pipeline

supplyAsync performs the initial work, thenApply transforms the successful value and exceptionally defines a fallback. The pipeline describes dependencies rather than manually nesting callbacks.

Code

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> message = CompletableFuture
            .supplyAsync(() -> "algogalaxy")
            .thenApply(String::toUpperCase)
            .exceptionally(error -> "FALLBACK");

        System.out.println(message.join());
    }
}

Expected Result

ALGOGALAXY

Example 4: Protect a Shared Counter

AtomicInteger performs an atomic increment without an exposed read-modify-write race. This is simpler and more scalable than synchronizing manually when the state is a single numeric counter.

Code

import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    static AtomicInteger completed = new AtomicInteger();

    static void markComplete() {
        completed.incrementAndGet();
    }

    public static void main(String[] args) {
        markComplete();
        markComplete();
        markComplete();
        System.out.println(completed.get());
    }
}

Expected Result

Example 5: Make the input visible

Start by naming the value the next line depends on. This keeps the lesson input explicit before we apply a transformation or call an external boundary. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        String lesson = "Advanced Java";
        System.out.println(lesson.toUpperCase());
    }
}

Expected Result

ADVANCED JAVA

Try next: Replace the sample value with one from your own notes, predict the result, and then run it.

Example 6: Make the input visible

Start by naming the value the next line depends on. This keeps the lesson input explicit before we apply a transformation or call an external boundary. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        String lesson = "Advanced Java";
        System.out.println(lesson.toUpperCase());
    }
}

Expected Result

ADVANCED JAVA

Try next: Replace the sample value with one from your own notes, predict the result, and then run it.

Example 7: Guard an empty boundary

A small guard makes the allowed and rejected path visible. We want a caller to receive an intentional result instead of discovering an unexplained failure later. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    static boolean accepted(String value) {
        return value != null && !value.isBlank();
    }

    public static void main(String[] args) {
        System.out.println(accepted("Advanced Java"));
    }
}

Expected Result

true

Try next: Try an empty value as well as the normal value and describe why the two outcomes differ.

Example 8: Keep the transformation pure

This step returns a value instead of mixing the rule with display or storage work. That separation gives us a small unit we can run, test, and reuse. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    static int doubleValue(int value) { return value * 2; }

    public static void main(String[] args) {
        System.out.println(doubleValue(6));
    }
}

Expected Result

Try next: Call the same rule twice with different inputs and confirm that each result depends only on its input.

Example 9: Make a branch deliberate

Use a named branch where the business rule changes. A future reader should be able to point at the condition and state the result for both sides. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        int score = 7;
        String result = score >= 5 ? "ready" : "review";
        System.out.println(result);
    }
}

Expected Result

ready

Try next: Change the boundary value by one and explain exactly which branch becomes active.

Example 10: Use a collection without hidden mutation

Collections become safer when we can see which value is read, which value is derived, and whether the original collection remains owned by the caller. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> lessons = List.of("Advanced Java", "boundary");
        System.out.println(String.join(" | ", lessons));
    }
}

Expected Result

Advanced Java | boundary

Try next: Add one more item and predict the derived result before executing the code.

Example 11: Return a named outcome

A named outcome is easier to test than an implied side effect. We can now distinguish a successful path from a rejected path without guessing from console noise. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    record Outcome(String status, String lesson) {}

    public static void main(String[] args) {
        Outcome outcome = new Outcome("ready", "Advanced Java");
        System.out.println(outcome.status());
    }
}

Expected Result

ready

Try next: Rename the outcome in your own words while preserving the same success and failure rule.

Example 12: Trace a small loop

Work through one value at a time. The point is not to memorize syntax; it is to see how the accumulator or output changes after each repeatable step. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        int total = 0;
        for (int value : new int[] {1, 2, 3}) total += value;
        System.out.println(total);
    }
}

Expected Result

Try next: Use a shorter collection first, then add one value and trace the extra iteration aloud.

Example 13: Keep display at the edge

The core rule prepares a value, while the outer line decides how to show it. That keeps the result usable by a UI, test, API, or command-line caller. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    static String display(String value) { return "Lesson: " + value; }

    public static void main(String[] args) {
        System.out.println(display("Advanced Java"));
    }
}

Expected Result

Lesson: Advanced Java

Try next: Change only the display text and verify that the underlying rule and result stay unchanged.

Example 14: Test the closest boundary

A useful example includes the nearest boundary, not only the happy path. We are making the behavior inspectable before a real caller relies on it. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    static int quantity(int value) {
        if (value < 1) throw new IllegalArgumentException("quantity must be positive");
        return value;
    }

    public static void main(String[] args) {
        System.out.println(quantity(1));
    }
}

Expected Result

Try next: Try the lowest supported value and then one value just outside the accepted range.

Example 15: Write a tiny regression check

A compact assertion turns the lesson into a repeatable promise. It helps us catch a changed rule before a larger program hides the source of the mistake. We are applying that habit while revisiting Advanced Java.

Keep the example small enough to trace. First predict the normal result; then change one input and explain the boundary result in your own words.

Java

public class Main {
    public static void main(String[] args) {
        String result = "Advanced Java".toUpperCase();
        if (!result.equals("ADVANCED JAVA")) throw new AssertionError("contract failed");
        System.out.println("contract holds");
    }
}

Expected Result

contract holds

Try next: Deliberately change the expected value once, observe the failed check, and then restore the correct contract.

Complexity Analysis

Operation	Complexity	Explanation
Record access	O(1) time	Record components are final fields exposed through generated accessors.
Atomic increment	O(1) expected operation	The JVM performs an atomic compare-and-set style update.
Async composition	Workload dependent	Composition overhead is small relative to the scheduled task work.

Common Mistakes

Creating unbounded raw threads instead of using an owned executor with a shutdown policy.
Calling get or join immediately after every CompletableFuture and losing asynchronous composition.
Assuming volatile makes a compound increment atomic.
Returning a mutable collection from an immutable-looking object without a defensive copy.

Interview Checklist

State who owns the executor, when it shuts down and how task failures are observed.
Choose AtomicInteger, synchronized or a concurrent collection based on the exact shared operation.
Explain asynchronous dependencies with thenApply versus thenCompose clearly.
Test success, task failure, timeout policy, cancellation and concurrent updates.