Modern Java for Interviews & Online Assessments

// Java 23/25: Imports all public packages exported by java.base
import module java.base;

void main() {
    List<String> names = List.of("Alice", "Bob", "Charlie");
    Map<Integer, List<String>> byLength = names.stream()
        .collect(Collectors.groupingBy(String::length));
    IO.println(byLength);
}

public record User(long id, String email, int age) {
    // Compact constructor: input validation & normalization
    public User {
        Objects.requireNonNull(email, "email must not be null");
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative: " + age);
        }
        email = email.trim().toLowerCase(); // Normalize before assignment
    }
}

class Channel {
    protected final int timeoutMs;

    protected Channel(int timeoutMs) {
        this.timeoutMs = timeoutMs;
    }
}

public class SecureChannel extends Channel {
    private final String cipherKey;

    public SecureChannel(String rawKey, int timeoutMs) {
        // Java 25 (final): Statements before super(...)!
        if (rawKey == null || rawKey.length() < 32) {
            throw new IllegalArgumentException("Key too short or null");
        }
        int sanitizedTimeout = Math.clamp(timeoutMs, 100, 10_000);

        super(sanitizedTimeout);
        this.cipherKey = rawKey;
    }
}

void main() {
    var tmp = new SecureChannel("Bozo Ozo Froso Wozo Sozo Mozo Katozo Olozo", 0);
    IO.println(tmp.cipherKey);
}

public sealed interface OrderStatus permits OrderStatus.Pending, OrderStatus.Shipped, OrderStatus.Delivered, OrderStatus.Cancelled {
    record Pending(Instant createdTime) implements OrderStatus {}
    record Shipped(String trackingNumber, Instant shippedTime) implements OrderStatus {}
    record Delivered(Instant deliveryTime, String recipientSignature) implements OrderStatus {}
    record Cancelled(String reason, Instant cancelTime) implements OrderStatus {}
}

// Flow scoping: 's' is only in scope where condition is guaranteed true
if (obj instanceof String s && !s.isBlank()) {
    IO.println("Length: " + s.length());
}

String describe(Object obj) {
    return switch (obj) {
        case null                  -> "Null reference";
        case Integer i when i < 0  -> "Negative integer: " + i;
        case Integer i             -> "Non-negative integer: " + i;
        case String s when s.isEmpty() -> "Empty string";
        case String s              -> "String of length " + s.length();
        case List<?> list          -> "List containing " + list.size() + " elements";
        default                    -> "Unknown object type: " + obj.getClass().getSimpleName();
    };
}

record Point(double x, double y) {}
record Circle(Point center, double radius) implements Shape {}
record Rectangle(Point topLeft, double width, double height) implements Shape {}

sealed interface Shape permits Circle, Rectangle {}

double calculateArea(Shape shape) {
    return switch (shape) {
        // Discard unneeded center point with '_' (JEP 456)
        case Circle(_, var radius) -> Math.PI * radius * radius;

        // Nested deconstruction: extract coordinates directly
        case Rectangle(Point(var x, var y), var w, var h) -> {
            IO.println("Top-left: (" + x + ", " + y + ")");
            yield w * h;
        }
    }; // NO 'default:' needed! Compiler proves Circle and Rectangle cover all Shape permits.
}

// Java 23/25 Primitive patterns (JEP 455): zero autoboxing overhead!
int statusCode = 200;
String status = switch (statusCode) {
    case 200 -> "OK";
    case 404 -> "Not Found";
    case int code when code >= 500 -> "Server Error (" + code + ")";
    case int code -> "Other Status: " + code;
};

SequencedCollection<String> items = new ArrayList<>(List.of("A", "B", "C", "D"));

String first = items.getFirst();       // "A"
String last  = items.getLast();        // "D"

items.addFirst("Z");                  // ["Z", "A", "B", "C", "D"]
items.removeLast();                   // Removes "D"

// Constant-time reversed view (not a copy!)
for (String s : items.reversed()) {
    IO.print(s + " ");                    // C B A Z
}

Map<String, List<String>> graph = new HashMap<>();

// 1. Grouping / Adjacency List: computeIfAbsent
graph.computeIfAbsent("NodeA", k -> new ArrayList<>()).add("NodeB");

// 2. Word Frequency / Counter: merge (1 line!)
Map<String, Integer> counts = new HashMap<>();
for (String word : words) {
    counts.merge(word, 1, Integer::sum);
}

// 3. Fallback queries: getOrDefault
int currentRank = counts.getOrDefault("target", 0);

record Candidate(String name, int score, int yearsExp) {}

List<Candidate> list = getCandidates();

// Multi-level sort: score descending, then yearsExp descending, then name alphabetically
list.sort(Comparator
    .comparingInt(Candidate::score).reversed()
    .thenComparingInt(Candidate::yearsExp).reversed()
    .thenComparing(Candidate::name)
);

// Handling nulls safely
list.sort(Comparator.nullsLast(Comparator.comparing(Candidate::name)));

record Transaction(String user, String currency, double amount) {}

List<Transaction> txs = getTransactions();

// Teeing: compute two independent reductions in a single pass (Java 12+)
record Stats(double sum, long count, double average) {}

Stats stats = txs.stream()
    .collect(Collectors.teeing(
        Collectors.summingDouble(Transaction::amount),
        Collectors.counting(),
        (sum, count) -> new Stats(sum, count, count == 0 ? 0 : sum / count)
    ));

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8);

List<List<Integer>> batches = numbers.stream()
    .gather(Gatherers.windowFixed(3))
    .toList();
// Output: [[1, 2, 3], [4, 5, 6], [7, 8]]

// Moving average calculation of window size 3
List<Double> prices = List.of(10.0, 12.0, 14.0, 16.0, 18.0);

List<Double> movingAverages = prices.stream()
    .gather(Gatherers.windowSliding(3))
    .map(window -> window.stream().mapToDouble(Double::doubleValue).average().orElse(0.0))
    .toList();
// Windows: [10, 12, 14] -> 12.0; [12, 14, 16] -> 14.0; [14, 16, 18] -> 16.0

// Prefix sums without mutable loops!
List<Integer> values = List.of(3, 1, 4, 1, 5);

List<Integer> prefixSums = values.stream()
    .gather(Gatherers.scan(() -> 0, Integer::sum))
    .toList();
// Output: [3, 4, 8, 9, 14]

// Spawning 100,000 concurrent tasks effortlessly!
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 100_000; i++) {
        final int taskId = i;
        executor.submit(() -> {
            Thread.sleep(Duration.ofMillis(100)); // Unmounts from carrier thread!
            return taskId * 2;
        });
    }
} // Auto-close joins and waits for all tasks!

record UserDashboard(User profile, List<Order> orders) {}

UserDashboard fetchDashboard(long userId) throws Exception {
    try (var scope = StructuredTaskScope.open(Joiner.<Object>awaitAllSuccessfulOrThrow())) {
        Subtask<User> userSubtask = scope.fork(() -> fetchUserProfile(userId));
        Subtask<List<Order>> ordersSubtask = scope.fork(() -> fetchRecentOrders(userId));

        scope.join(); // Propagates first failure, cancelling siblings!

        return new UserDashboard(userSubtask.get(), ordersSubtask.get());
    }
}

public static final ScopedValue<SecurityContext> CURRENT_USER = ScopedValue.newInstance();

void handleRequest(Request req) {
    SecurityContext ctx = authenticate(req);
    ScopedValue.where(CURRENT_USER, ctx).run(() -> {
        processOrder(); // Downstream methods call CURRENT_USER.get() with zero memory leak risk!
    });
}

public class PricingService {
    public double calculateTotal(double basePrice, UnaryOperator<Double> discountStrategy) {
        return discountStrategy.apply(basePrice);
    }
}

// Usage:
service.calculateTotal(100.0, price -> price * 0.85); // Inline lambda
service.calculateTotal(100.0, PricingStrategies::holidayDiscount); // Method reference

sealed interface Expr permits Constant, Add, Multiply {}
record Constant(double val) implements Expr {}
record Add(Expr left, Expr right) implements Expr {}
record Multiply(Expr left, Expr right) implements Expr {}

double eval(Expr expr) {
    return switch (expr) {
        case Constant(var val)          -> val;
        case Add(var left, var right)      -> eval(left) + eval(right);
        case Multiply(var left, var right) -> eval(left) * eval(right);
    };
}

public enum CacheManager {
    INSTANCE;
    public void put(String k, Object v) { /* ... */ }
}

public class DatabaseClient {
    private DatabaseClient() {}

    private static class Holder {
        private static final DatabaseClient INSTANCE = new DatabaseClient();
    }

    public static DatabaseClient getInstance() {
        return Holder.INSTANCE; // ClassLoader guarantees thread-safety
    }
}

try (var in = new FileInputStream("data.txt");
     var out = new FileOutputStream("out.txt")) {
    in.transferTo(out);
} catch (IOException e) {
    IO.println("Primary error: " + e.getMessage());
    for (Throwable suppressed : e.getSuppressed()) {
        IO.println("Suppressed during close: " + suppressed.getMessage());
    }
}

// Zero stack-trace overhead; expressive domain failure modeling
public sealed interface Result<T, E> permits Result.Success, Result.Failure {
    record Success<T, E>(T value) implements Result<T, E> {}
    record Failure<T, E>(E error) implements Result<T, E> {}

    default boolean isSuccess() { return this instanceof Success; }
}

Result<User, String> res = findUser("alice@corp.com");
String message = switch (res) {
    case Result.Success(var user) -> "Found user: " + user.name();
    case Result.Failure(var err)  -> "Lookup failed: " + err;
};

// The happens-before guarantee guarantees visibility and ordering:
// 1. volatile write happens-before subsequent volatile read of same variable.
// 2. Unlocking a monitor happens-before subsequent lock of same monitor.
// 3. Thread.start() happens-before any action in the started thread.
// 4. Thread termination happens-before Thread.join() returns.

// Off-heap native memory allocation with automatic lifecycle management
try (Arena arena = Arena.ofConfined()) {
    // Allocate 1,024 bytes off-heap outside JVM GC management
    MemorySegment segment = arena.allocate(1024);

    // Write a 64-bit long at offset 0
    segment.set(ValueLayout.JAVA_LONG, 0, 42_000_000L);

    long val = segment.get(ValueLayout.JAVA_LONG, 0);
    IO.println("Native value: " + val);
} // Arena closed: native memory deallocated instantly with zero memory leaks!

import module java.base;

public class FastIO {
    static class FastReader {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    String line = br.readLine();
                    if (line == null) return null;
                    st = new StringTokenizer(line);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }
            return st.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }
        long nextLong() { return Long.parseLong(next()); }
    }

    public static void main(String[] args) {
        FastReader in = new FastReader();
        // Read fast inputs without TLE
    }
}

Integer a = 127, b = 127;
IO.println(a == b);      // true (cached flyweights)

Integer c = 128, d = 128;
IO.println(c == d);      // FALSE! Distinct heap instances!
IO.println(c.equals(d)); // true: ALWAYS use .equals() for wrapper comparisons!

// WRONG: (low + high) can overflow positive 32-bit int if both are > 1 billion
int mid = (low + high) / 2;

// CORRECT: subtractive midpoint or bitwise shift
int mid = low + (high - low) / 2;
// OR:
int mid = (low + high) >>> 1; // Unsigned right shift preserves sign bit

// WRONG: -1 % 5 == -1 in Java!
int index = val % k;

// CORRECT: wrap-around positive modulo
int index = (val % k + k) % k;
// OR:
int index = Math.floorMod(val, k);

Integer[] arr = {1, 2, 3};
List<Integer> list1 = Arrays.asList(arr);
// list1.add(4); // THROWS UnsupportedOperationException! Fixed-size list backed by array.
list1.set(0, 99); // MUTATES original array arr[0]!

List<Integer> list2 = List.of(1, 2, 3);
// list2.set(0, 99); // THROWS UnsupportedOperationException! Truly unmodifiable.

IO.println(0.1 + 0.2); // Prints 0.30000000000000004!

BigDecimal price1 = new BigDecimal("0.1"); // Always construct from String, not double!
BigDecimal price2 = new BigDecimal("0.2");
IO.println(price1.add(price2)); // Prints 0.3 exact

Object[] arr = new String[5]; // Compiles because Java arrays are covariant!
arr[0] = 123; // Compiles, but THROWS ArrayStoreException at runtime!

// WRONG (Java 8 trap): SimpleDateFormat shared across threads corrupts internal Calendar state!
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

// MODERN JAVA (Thread-safe, immutable, nanosecond precision):
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate date = LocalDate.parse("2026-10-01", formatter);
Instant timestamp = Instant.now();
ZonedDateTime utcTime = timestamp.atZone(ZoneId.of("UTC"));

// Legacy: pool of 200 OS threads (risks thread starvation during I/O spikes)
// ExecutorService pool = Executors.newFixedThreadPool(200);

// Modern Java 21-25: Virtual threads per task (millions concurrent, non-exhausting)
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> httpClient.send(request, HttpResponse.BodyHandlers.ofString()));
}

import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.assertAll;

@DisplayName("User Account Service Tests")
class UserServiceTest {

    private final UserService service = new UserService();

    @Nested
    @DisplayName("When registering a new user")
    class RegistrationTests {

        @Test
        @DisplayName("Should successfully create active user with normalized email")
        void shouldCreateActiveUser() {
            var request = new RegisterRequest("  ALICE@CORP.COM  ", "Secret123!");
            User user = service.register(request);

            // AssertJ: fluent, chained, readable failure messages
            assertThat(user)
                .isNotNull()
                .satisfies(u -> {
                    assertThat(u.email()).isEqualTo("alice@corp.com");
                    assertThat(u.isActive()).isTrue();
                    assertThat(u.createdAt()).isBeforeOrEqualTo(Instant.now());
                });
        }

        // Modern Parameterized Testing
        @ParameterizedTest(name = "Invalid email '{0}' should throw exception")
        @ValueSource(strings = {"", "   ", "missing-at-sign", "@nodomain.com"})
        void shouldRejectInvalidEmails(String invalidEmail) {
            assertThatThrownBy(() -> service.register(new RegisterRequest(invalidEmail, "Secret123!")))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessageContaining("Invalid email");
        }
    }
}

@Test
@Timeout(value = 3, unit = TimeUnit.SECONDS) // Fails test if virtual thread deadlocks!
@DisplayName("Should process 1,000 tasks concurrently on virtual threads")
void shouldProcessTasksConcurrently() throws Exception {
    var counter = new LongAdder();
    int taskCount = 1_000;

    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
        List<Future<?>> futures = IntStream.range(0, taskCount)
            .mapToObj(i -> executor.submit(() -> {
                counter.increment();
            }))
            .toList();

        // Wait deterministically for all tasks
        for (var f : futures) {
            f.get(1, TimeUnit.SECONDS);
        }
    }

    assertThat(counter.sum()).isEqualTo(taskCount);
}

import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
class CustomerRepositoryIT {

    // Starts a real PostgreSQL container before tests run; tears it down when done
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");

    @Test
    void shouldPersistAndRetrieveCustomerWithJsonb() {
        String jdbcUrl = postgres.getJdbcUrl();
        var dataSource = createDataSource(jdbcUrl, postgres.getUsername(), postgres.getPassword());
        var repo = new CustomerRepository(dataSource);

        repo.save(new Customer("c1", "Alice", "{\"tier\": \"gold\"}"));
        Customer found = repo.findById("c1").orElseThrow();

        assertThat(found.name()).isEqualTo("Alice");
    }
}