Java Interview Questions

Explain that a method receives a copy of the argument value, including a copied reference. Show the difference between changing an object and reassigning the parameter.

Describe equality properties and equal objects having equal hash codes. Discuss mutable keys in hash-based collections.

Compare contracts, shared state and implementation reuse. Explain how composition keeps responsibilities replaceable.

Discuss final fields, construction safety and defensive copies. A final reference does not make the referenced collection immutable.

Explain declaration and handling requirements. Choose an exception strategy based on recoverability and the API contract.

Compare indexed access, traversal and insertion when the position is already known. Include allocation and cache-locality costs.

Compare key ordering, comparison rules and lookup complexity. Explain when a sorted map is useful.

Use a collection example to show why a List of a subtype cannot safely substitute for every List of its parent type.

Explain reading from a producer and writing to a consumer. Show a copy operation with constrained source and destination types.

Explain whether later mutations in an underlying collection become visible. Distinguish shallow copying from deep immutability.

Explain laziness and when traversal begins. Describe why a consumed stream cannot simply be reused.

Compare transforming one value with flattening nested results. Use an example involving optional or collection-valued results.

Discuss shared mutable state, execution order and parallel execution. Prefer explicit accumulation or a suitable collector.

Consider data size, splitting cost, CPU work and the shared execution environment. Measure rather than assuming parallel is faster.

Use it to express an absent result where appropriate. Explain eager versus lazy fallback computation and avoid unchecked get calls.

Describe method execution and object reachability. Avoid claiming that every implementation must allocate every object identically.

Explain unintended retention through static collections, listeners or thread-local values. Identify the reference chain keeping objects reachable.

Discuss allocation rate, live-set size, heap configuration and collector choice. Use logs and a workload profile before tuning.

Correlate thread activity with stack samples and application traces. Distinguish busy application work, contention and garbage collection.

Explain runtime profiling and optimized compilation. Describe warmup effects and why a naive timing loop can mislead.

Explain mutual exclusion and visibility guarantees. A volatile counter increment is still a compound operation.

Describe the ordering and visibility guarantees used to reason about shared state. Use a lock or safe-publication example.

Connect pool size and queue capacity to CPU or I/O workloads. Include overload rejection, shutdown and cancellation.

Discuss blocking I/O concurrency and why virtual threads do not make CPU-bound work faster. Preserve limits on scarce downstream resources.

Explain composition, exceptional completion and explicit executor choices. Avoid silently swallowing failures or blocking dependent work.

Discuss constructor injection, explicit dependencies and replaceable boundaries. Explain that injection alone does not guarantee good separation of responsibilities.

Explain the container-scoped shared instance and why mutable state must be handled safely across requests.

Discuss which calls pass through the proxy. Explain why an internal self-invocation may bypass transactional advice.

Validate at boundaries, choose suitable status codes and maintain a consistent error contract. Avoid exposing internal details.

Cover endpoint and service-level permission checks. Treat CORS, identity verification and access decisions as separate concerns.

Trace the repeated queries during relationship access. Compare projections, fetch joins and batched loading for the specific use case.

Explain a version check and conflict detection. Describe when to retry and when the caller must resolve the conflict.

Discuss anomalies relevant to the invariant being protected. Include the concurrency cost of stronger isolation.

Use a deterministic sort and a tie-breaker. Compare large offsets with a keyset cursor and appropriate indexes.

Explain the failure window between a commit and sending a message. Describe an outbox and idempotent consumers.

Choose queue capacity, blocking or rejection behavior and a shutdown protocol. Explain how failures propagate to producers and consumers.

Define cache keys, expiry and invalidation. Discuss stampede protection and whether stale data is acceptable.

Persist an idempotency key and outcome with appropriate transactional protection. Handle concurrent duplicates and unknown external outcomes.

Explain lock ordering, waiting dependencies and how a thread dump supports the diagnosis. Reduce lock scope or remove cyclic acquisition.

Cover consumers, schema evolution, deployment order and observability. Define how old and new application versions coexist.