Top 5 Java Interview Questions in 2026 (And How to Answer Them)

Virtual threads (Project Loom, Java 21+) are lightweight threads managed by the JVM, not the OS. They let you run millions of concurrent tasks without creating millions of OS threads.

When to use: I/O-bound workloads — HTTP handlers, database queries, message consumers. Anywhere you'd use CompletableFuture or a thread pool with blocking calls.

When NOT to use: CPU-intensive tasks. Virtual threads don't make a single computation faster — they solve concurrency, not parallelism.

A record is a transparent, immutable data carrier. The compiler auto-generates the constructor, equals(), hashCode(), and toString().

Key differences:

• Records are implicitly final — can't be extended
• Components are private final — no setters
• Can't declare instance fields beyond the record components
• Can implement interfaces but not extend classes

Think of them as Data classes in Kotlin or @data in Lombok, but built into the language with proper semantics.

sealed classes restrict which classes can extend them. Combined with pattern matching, they give you exhaustive switch expressions — the compiler forces you to handle every case.

Use case: Domain modeling. Instead of an enum (fixed values), you get a closed hierarchy of types with different fields.

sealed interface Shape permits Circle, Rectangle, Triangle {}
// compiler error if you forget a case in switch

This eliminates instanceof chains and makes refactoring safe — adding a new subtype forces you to update every switch.

Pattern matching combines type checking, type casting, and destructuring into one syntax:

switch (shape) {
    case Circle c    -> "circle with radius " + c.radius();
    case Rectangle r -> "rectangle " + r.width() + "x" + r.height();
    case Triangle t  -> "triangle";
}

Guards: case Integer i when i > 100 — add conditions to patterns.

null handling: case null is now valid in switch — no more NullPointerException surprises.

GraalVM is a high-performance polyglot VM. For Java, it offers two big things:

• Native Image: Compiles Java to a standalone native binary. Startup in milliseconds, low memory — perfect for serverless, CLI tools, and microservices.
• Truffle language interop: Run Java, JavaScript, Python, and R in the same process with zero-copy data exchange.

Trade-off: Native Image has a long build time and limited reflection support (you need native-image.properties configs). For traditional long-running servers, HotSpot is still fine.