Java Interview Questions & Answers

Fail-fast means that the iteration fails immediately with a ConcurrentModificationException if a collection structure is modified during an iteration (like in an ArrayList and  HashMap). Fail-safe doesn’t raise an exception in these conditions, because it operates in a collection copy (like in CopyOnWriteArrayList).

 

Virtual threads are lightweight, low-cost threads that the JVM runtime maps to a small number of operating system (platform threads). Project Loom introduced them to simplify concurrent programming. Their main goal is scalability, as virtual threads create millions of threads without exhausting system resources, making asynchronous code easier to read and debug because it looks like synchronous code.

An object is immutable when its state cannot be changed after creation. To create an immutable class, you must declare the class as final, ensure all fields are final, and defensively clone any mutable objects within the class in getters and the constructor.

Immutability is important for three reasons: it’s inherently thread-safe, it simplifies code (because the object’s state doesn’t change), and it enhances security (by preventing unexpected changes).

The DIP states that high-level modules should not depend on low-level modules; both should depend on abstractions. Furthermore, abstractions should not depend on details; details should depend on abstractions. Dependency Injection is the technique that implements the DIP, where an object’s dependencies are provided externally instead of being created internally. Frameworks like Spring and Jakarta EE use DI extensively.

Both patterns use composition and are based on changing behavior, but for different purposes. The Strategy pattern encapsulates interchangeable algorithms, allowing the client to choose which one to use at runtime (e.g., different sorting algorithms). The State pattern is used when an object’s behavior changes based on its internal state. It allows the object to change its class at runtime (e.g., an order object that changes state from “processing” to “shipped”).

The garbage collector (GC) is an automatic JVM process that reclaims memory from objects that are no longer being referenced. The object generations are:

• Young Generation: Where objects are initially allocated. It’s divided into Eden, S0, and S1. Garbage collection here is fast (minor GC).
• Old Generation: Objects that survive multiple young generation collections are “promoted” here. Garbage collection here is rarer but slower (major GC).
• Metaspace: Stores class metadata (like definitions and methods). Unlike the old PermGen, Metaspace grows dynamically and is managed by the GC, preventing OutOfMemoryErrors due to class metadata.

Maven is a build system based on convention over configuration. Its configuration files (pom.xml) are XML and follow a strict build lifecycle model. Gradle is more flexible, using a Groovy or Kotlin-based Domain-Specific Language (DSL), which makes it more programmable. It’s known for better performance with incremental builds and native support for multi-project builds.

A microservices architecture is an approach where a single application is composed of several small, independent, and loosely coupled services that communicate with each other. Each service has its own database and can be developed, deployed, and scaled independently. Challenges include:

• Distributed communication (latency, network failures).
• Data management (distributed transactions).
• Operational complexity (monitoring, logging, and debugging in distributed environments).
• Fault tolerance.

The Circuit Breaker pattern prevents a client system from repeatedly trying to access a service that is down. It acts like an electrical circuit breaker, “opening” the circuit after some failures to prevent subsequent calls and allow the failing service to recover. Hystrix and Resilience4j implement this by providing three states: Closed (normal), Open (stops calls), and Half-Open (allows a few test calls to check for recovery).

Using a profiling tool such as JProfiler, VisualVM, or Java Flight Recorder (JFR) to:

• Find CPU bottlenecks: Analyze threads and call stacks to identify methods that consume the most time.
• Analyze memory usage: Analyze the heap dump to identify which objects are consuming the most memory and find potential leaks.
• Monitor the garbage collector: Evaluate the frequency and duration of GC pauses to fine-tune memory allocation.

“Concise Source Files” simplifies the entry point for an application. Instead of requiring an explicit class and the public static void main(String[] args) method, a developer can write a .java file with more direct code. This new feature makes the learning curve smoother and the process of starting to code much faster. Now you don’t have to worry about learning OOP before printing “Hello World” in Java. The impact on the market will be that more junior Java developers will be available in the following years.

Scoped Values work like ThreadLocals. They share immutable data within a call chain, but without the risk of memory leaks. Scoped Values are read only once and cannot be changed, which makes them much more efficient and safer for passing data like request IDs or authentication tokens in environments with a high number of virtual threads.

In Java 25, the size of object headers can be reduced from 12 to 8 bytes in 64-bit environments. For applications with millions of objects in memory, this optimization can free up a significant amount of heap space, improving overall performance and the JVM’s cache efficiency.

Ahead-of-Time Method Profiling allows the Just-in-Time (JIT) compiler to reuse execution profile information from a previous run. Instead of having to “learn” the code usage patterns with each new execution, the compiler already has data on the most-used methods and can optimize the code faster. The result is a significantly shorter “warm-up” time for the application.

Generational Shenandoah is a version of the Shenandoah garbage collector that now separates newly created objects (young generation) from long-lived objects (old generation). This allows for a more efficient garbage collector in the young generation, resulting in even smaller and less frequent pauses for the application’s garbage collector.