Java Interview Questions

Java is a high-level, object-oriented programming language that is platform-independent and widely used for building applications.

Java features include platform independence, object-oriented design, robustness, security, multithreading, and automatic garbage collection.

The Java Virtual Machine (JVM) is an engine that provides a runtime environment to execute Java bytecode. It helps achieve platform independence.

JDK (Java Development Kit) is used for developing Java applications, while JRE (Java Runtime Environment) is used for running them.

'final' is used to declare constants, prevent method overriding, and prevent inheritance in Java.

Java Collections are a set of classes and interfaces that implement commonly reusable collection data structures like List, Set, and Map.

A constructor is a special method used to initialize objects. It has the same name as the class and does not have a return type.

Method overloading in Java is when two or more methods in the same class have the same name but different parameters.

'==' checks reference equality (whether two references point to the same object), while 'equals()' checks content equality (whether the two objects are logically equal).

Access modifiers in Java are keywords like 'public', 'private', 'protected', and 'default' that define the visibility of classes, methods, and variables.

Multithreading is the concurrent execution of more than one sequential set of instructions, or thread. It improves the performance of applications by doing multiple tasks at the same time.

Exception handling in Java is a mechanism that allows the handling of runtime errors to maintain the normal flow of application execution using 'try', 'catch', 'finally' blocks.

Lambda expressions are a way to provide clear and concise syntax for writing anonymous methods (functional interfaces).

Java Streams allow functional-style operations on sequences of elements (like arrays or collections), such as filtering, mapping, and reducing.

An interface in Java is an abstract type that defines a contract of methods which implementing classes must provide implementations for.

A package in Java is a namespace that organizes classes and interfaces into a directory structure.

ArrayList provides fast random access with O(1) average get operations and is the usual default. LinkedList has O(1) insertion or deletion only when the node is already located, but traversal and memory overhead often make it slower in practice.

String is immutable, meaning its value cannot be changed once created. StringBuilder is mutable, and its value can be modified.

The 'super' keyword refers to the immediate parent class of the current object and is used to invoke superclass methods or constructors.

Garbage collection in Java is the process of automatically reclaiming memory by removing objects that are no longer in use.

A thread in Java is a lightweight process that can run concurrently with other threads, enabling multitasking in applications.

Serialization is the process of converting an object into a byte stream, allowing it to be saved to a file or transmitted over a network.

The 'this' keyword refers to the current instance of the class. It is often used to distinguish instance variables from parameters.

Reflection in Java allows you to inspect and modify the properties, methods, and behaviors of classes at runtime.

'throw' is used to explicitly throw an exception, while 'throws' is used to declare that a method may throw an exception.

If two objects are equal according to equals(), they must return the same hashCode(). A class that overrides equals() should therefore override hashCode() too, otherwise HashMap and HashSet can behave incorrectly.

volatile guarantees visibility of a variable across threads but does not make compound operations atomic. synchronized provides mutual exclusion and visibility, so it is needed when multiple operations must happen as one critical section.

CompletableFuture represents an asynchronous computation that can be composed with stages such as thenApply, thenCompose, and exceptionally. It is useful for coordinating non-blocking workflows, but its executor, timeout, and error-handling policies must be designed explicitly.

A record is a concise, shallowly immutable data carrier that supplies accessors, equals(), hashCode(), and toString(). A sealed class or interface restricts which types may extend or implement it, making a closed domain model easier to validate and pattern-match.

Confirm the growth with metrics, inspect heap usage and garbage-collection pauses, then capture a heap dump and identify dominators or retained references. Common causes include unbounded caches, static collections, listener leaks, and oversized request data; fix the ownership or eviction policy rather than only increasing the heap.

Virtual threads are lightweight Java threads designed for high-concurrency, mostly blocking I/O workloads. They can simplify request-per-task code, but they do not make CPU-heavy work faster; bound database connections and external resources, avoid pinning on long synchronized sections, and measure throughput before migrating.

Platform threads are typically backed one-to-one by operating-system threads and are relatively expensive. Virtual threads are managed by the JVM and are mounted on a smaller pool of carrier threads, allowing many waiting tasks, but native calls, pinning, and limited downstream resources can still constrain a service.

Separate CPU-bound and I/O-bound work, size pools from measured workload and downstream limits, use bounded queues, define rejection or backpressure behavior, and propagate timeouts and cancellation. An unbounded executor can turn traffic spikes into memory exhaustion instead of protecting the service.