Question 1

Explain Java Generics and Type Erasure.

Accepted Answer

Java Generics provide compile-time type safety. Type Erasure is the compiler behavior where generic type parameters are replaced with their bounds (or `Object`) during compilation. This means that type parameters do not exist at runtime, which was designed to preserve backward compatibility.

Question 2

Explain Java Concurrency: ExecutorService and Thread Pools.

Accepted Answer

`ExecutorService` manages asynchronous execution threads. It handles a queue of tasks and routes them to a pool of worker threads (configured using `Executors`), avoiding thread creation overhead.

Question 3

What is the difference between HashMap and ConcurrentHashMap in Java?

Accepted Answer

- `HashMap`: Not thread-safe. Concurrent access can cause infinite loops or data corruption.
- `ConcurrentHashMap`: Thread-safe. It optimizes concurrency by locking specific segments of the map (bucket level locks) rather than locking the entire map instance.

Question 4

How do you write unit tests in Java using JUnit and Mockito?

Accepted Answer

Write unit tests using JUnit annotations (like `@Test`). Mock dependencies using Mockito's `@Mock` and stub methods: `when(service.getData()).thenReturn(mockData);` to isolate testing targets.

Question 5

Explain Java Garbage Collection algorithms: G1GC vs ZGC.

Accepted Answer

- `G1GC` (Garbage-First): Divides the heap into regions, executing mark-sweep passes on regions containing the most garbage.
- `ZGC` (Z Garbage Collector): A concurrent collector that processes sweeps without stopping threads, keeping STW pauses sub-millisecond.

Question 6

What is Java Reflection and what are its security risks?

Accepted Answer

Reflection lets you inspect and modify classes, methods, and fields at runtime (including private members). Security risks include bypassing encapsulation boundaries and degrading performance.

Question 7

How do you trace memory leaks in Java using JProfiler or VisualVM?

Accepted Answer

Connect VisualVM to the running JVM. Trigger GC, take heap dumps during load tests, and analyze objects with the highest instance counts (like strings or collections) to identify leak sources.

Question 8

What is the difference between abstract classes and interfaces in Java 8+?

Accepted Answer

In Java 8+, interfaces can define `default` and `static` methods with implementations, closing the gap with abstract classes. However, abstract classes can still hold state fields, whereas interfaces cannot.

Question 9

How do you mock static methods in Java tests?

Accepted Answer

In Mockito 3.4+, mock static methods using the `mockStatic` API block:
```java
try (MockedStatic<Helper> mocked = mockStatic(Helper.class)) {
  mocked.when(Helper::run).thenReturn("mocked");
}
```

Question 10

Explain class loading in Java and the delegation model.

Accepted Answer

Java ClassLoaders load class bytes on demand. They follow a hierarchical delegation model: a class loader delegates loading tasks to its parent loader first, loading locally only if the parent fails.

Question 11

Explain how to write custom filters in Java web servers.

Accepted Answer

Implement the `javax.servlet.Filter` interface and override the `doFilter()` method. Intercept request/response streams, execute logic (like auth checks), and call `chain.doFilter()` to continue.

Question 12

What is the difference between Callable and Runnable in Java?

Accepted Answer

- `Runnable` defines a `run()` method returning void and cannot throw checked exceptions.
- `Callable` defines a `call()` method returning a value and can throw checked exceptions.

Question 13

How does Java handle autoboxing and unboxing?

Accepted Answer

Autoboxing is the automatic conversion the compiler performs between primitives and their wrapper classes (e.g. converting `int` to `Integer`). Unboxing is the reverse. Overusing it in loops degrades performance.

Question 14

Explain Java Annotations and how they are parsed at runtime.

Accepted Answer

Annotations are metadata tags. If annotated with `@Retention(RetentionPolicy.RUNTIME)`, Java APIs can inspect and parse these tags at runtime using reflection, which is common in Spring configurations.

Question 15

How do you prevent thread deadlocks in Java applications?

Accepted Answer

Avoid nested locks. If nested locks are required, ensure all threads acquire locks in the exact same order, and use timed lock attempts (`tryLock()`) to prevent infinite blocks.

Question 16

How do you run integration tests with MockMvc in Spring Boot?

Accepted Answer

Annotate the test class with `@AutoConfigureMockMvc`. Inject `MockMvc` to trigger mock requests to the controller endpoints, asserting returned status codes and JSON payloads.

Question 17

Explain Java Memory Management (JVM Heap structure, Metaspace, GC roots) and how to debug OutOfMemoryError.

Accepted Answer

The JVM divides memory into spaces:
1. Heap: Divided into Young Generation (Eden, Survivor spaces S0/S1) and Old Generation. Eden stores new allocations, S0/S1 holds survivors, and Old Generation holds long-lived objects.
2. Metaspace: Stores class metadata outside the JVM heap in native memory.
3. GC Roots: Objects always reachable (stack variables, JNI references, active threads).

OutOfMemoryError (OOM) occurs when memory runs out. Debug this by starting the JVM with `-XX:+HeapDumpOnOutOfMemoryError`, loading the dump in Eclipse MAT, and tracing the object path to identify leak sources.

Question 18

How do you configure JVM tuning parameters for enterprise microservices (garbage collectors, memory limits)?

Accepted Answer

Optimize JVM options for microservices by:
1. Memory Limits: Set `-Xms` (initial heap) and `-Xmx` (max heap) to identical values to prevent resize pauses, keeping them below container limits to avoid OOM kills.
2. Garbage Collector: Set `-XX:+UseG1GC` or `-XX:+UseZGC` for low-latency APIs. Set pause targets using `-XX:MaxGCPauseMillis=50`.

Question 19

Explain distributed context propagation inside Spring Cloud microservices architectures.

Accepted Answer

Context propagation involves passing trace context (Trace IDs) across microservices. Spring Cloud Sleuth or OpenTelemetry intercepts REST calls (using WebClient or RestTemplate interceptors) and injects headers, letting tracing systems correlate logs.

Question 20

Explain Java security best practices: protecting against serialization attacks and memory leaks.

Accepted Answer

Secure Java applications by:
1. Deserialization: Avoid Java native serialization; use JSON or Protocol Buffers. If native is required, validate input streams using ObjectInputFilter.
2. Prevent Memory Leaks: Avoid static collections that hold object references, and use WeakReferences where cache structures are required.

Question 21

How would you implement a distributed locks system in Java using Redisson?

Accepted Answer

Use Redisson's `RLock` API. It implements Redis-based locks. It uses a watchdog mechanism that automatically extends lock lifetimes if the thread is still processing, preventing locks from expiring during slow queries.

Question 22

Explain how to write custom classloaders in Java.

Accepted Answer

Extend the `ClassLoader` class and override the `findClass()` method. Read class bytes from a custom source (like an encrypted file or database), and call `defineClass()` to load the class into the JVM.

Question 23

How do you debug thread issues using JVM thread dumps?

Accepted Answer

Generate thread dumps using `jcmd` or `jstack`. Open the dump in analysis tools to search for threads in the `BLOCKED` state, identifying which thread holds the lock and which thread waits on it.

Question 24

Explain the differences between JVM JIT compiler compilation levels.

Accepted Answer

The HotSpot JVM uses tiered compilation. Level 0 runs interpreter code. Levels 1-3 compile code quickly using C1 compiler profiling. Level 4 optimizes loops and compiles hot code using the C2 compiler.

Question 25

How do you set up distributed session management in Spring Boot?

Accepted Answer

Register Spring Session with a Redis backend. This replaces the default servlet container session store, caching session data in Redis so any clustered instance can validate requests.

Question 26

How do you optimize memory allocations inside Java Collections?

Accepted Answer

Pre-size collections by specifying initial capacities: `new HashMap<>(expectedSize / 0.75f + 1)`. This avoids rehashing overhead and array resize steps as elements are inserted.

Question 27

Explain how Java compiles and links static binaries under GraalVM.

Accepted Answer

GraalVM Native Image performs ahead-of-time (AOT) compilation. It parses all reachable classes, strips unused JVM code, and compiles the application directly into a self-contained OS binary, reducing startup times.

Question 28

How do you profile garbage collection latencies using JVM logs?

Accepted Answer

Enable GC logging using `-Xlog:gc*:file=gc.log:time,uptime,level,tags`. Parse this log in tools (like GCViewer) to analyze stop-the-world durations and memory reclamation rates.

Question 29

Explain how Java reflection affects JIT compiler optimizations.

Accepted Answer

Reflection checks methods at runtime, bypassing compile-time checks. This prevents the JIT compiler from optimizing method calls (like inlining code), degrading API throughput if run inside loops.

Question 30

How do you implement secure rate-limiting using Token Buckets in Java?

Accepted Answer

Use libraries like Bucket4j. Define a bucket configuration specifying token capacities and refill rates. Check limits on incoming requests: `bucket.tryConsume(1)`, blocking calls if empty.

Question 31

How do you build a custom router engine using Radix trees in Java?

Accepted Answer

Implement a Radix tree node data structure. Match incoming request URI paths against the tree nodes recursively, capturing variables and mapping routes to controller methods.

Question 32

Explain JVM Off-Heap memory allocations and when to use them.

Accepted Answer

Off-Heap memory (allocated via `ByteBuffer.allocateDirect()`) stores data outside the JVM heap. This avoids GC scans, making it ideal for caching large datasets or network transfers (Zero-Copy).

Question 33

How do you debug memory leaks in class loaders?

Accepted Answer

Metaspace memory leaks occur if class loaders are not garbage collected after unloading classes. Profile Metaspace using heap analyzers to verify class loaders are dereferenced properly.

Senior Java Interview Questions (5+ Years Experience) (2026)

What is Java and Why is it Critical in Modern Engineering?

Java Lifecycle Visualizer

Core Architectural Concepts in Java

JVM Garbage Collection

Multithreading Execution

Spring Bean Lifecycle

Strict Types OOP Rules

Hibernate Cache Layers

check_circleWhy Modern Companies Choose Java

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Architecture