Java interview questions

JVM is the runtime engine that executes Java bytecode. JRE provides the JVM plus the libraries needed to run Java programs. JDK contains the JRE along with development tools such as `javac`, `javadoc`, and debugger tools.

A simple interview way to say it is: JVM runs the code, JRE runs Java applications, and JDK is used to develop Java applications. If you can compile code, you need JDK. If you only want to run compiled Java code, JRE is enough in theory.

Java is called platform independent because Java source code is compiled into bytecode, and that bytecode can run on any system that has a compatible JVM. The same `.class` file can therefore run on different operating systems without recompiling the source code.

This is why Java is often explained using the phrase 'write once, run anywhere'. The source code is not executed directly by the hardware; the JVM sits in between and handles platform-specific execution details.

Java is not considered purely object-oriented because it supports primitive data types such as `int`, `char`, `double`, and `boolean`, which are not objects. In a purely object-oriented language, everything would be treated as an object.

Java is still strongly object-oriented in design, but primitives are kept for performance and simplicity. In interviews, that one point about primitive types is usually the expected answer.

Primitive data types directly store simple values such as numbers or booleans. Reference data types store a reference to an object or array instead of storing the full object content directly in the variable.

For example, `int x = 5;` stores the value directly, while `String name = "Java";` stores a reference to a string object. In interviews, compare them using stored value, memory behavior, and null support.

Wrapper classes are object versions of primitive types, such as `Integer` for `int` and `Double` for `double`. Autoboxing is the automatic conversion from primitive to wrapper object, and unboxing is the reverse conversion from wrapper object to primitive.

Wrapper classes are useful when Java APIs require objects, such as collections like `ArrayList<Integer>`. In interviews, mention that autoboxing is convenient, but too much unnecessary boxing can create extra overhead.

Java is always pass-by-value. For primitive types, the actual value is copied. For objects, the reference value is copied, which means the method receives a copy of the reference, not the original variable itself.

This is why a method can change the internal state of an object through the copied reference, but it cannot make the caller's reference variable point to a different object. In interviews, this question is common because many candidates say Java is pass-by-reference, which is not correct.

Stack memory is mainly used for method calls, local variables, and method execution frames. Heap memory is used for objects and arrays created at runtime. Stack storage is usually short-lived and method-based, while heap storage is shared and managed by garbage collection.

A common interview summary is: stack handles execution flow, heap handles object storage. Local primitive variables often live in stack frames, while objects created with `new` are usually placed on the heap.

A classloader is the part of the JVM that loads class files into memory when they are needed. It helps the JVM find, load, and link classes during runtime.

In interviews, it is enough to say that Java uses classloaders to dynamically load classes instead of loading everything at once. If needed, you can also mention the common hierarchy of bootstrap, platform, and application classloaders.

`public` allows the JVM to access it from outside the class. `static` lets the JVM call it without creating an object. `void` means it does not return a value, and `String[] args` allows command-line arguments to be passed to the program.

This question is usually asked to check whether you understand the reason behind the standard entry-point signature. In interviews, explain each keyword briefly instead of only memorizing the full line.

`final` is a keyword used to restrict change, such as for variables, methods, and classes. `finally` is a block used with exception handling to run cleanup code. `finalize()` was a method related to garbage collection, but it is deprecated and should not be relied on.

These three terms sound similar, so interviewers often use them as a trap. The best answer is to separate them clearly by category: keyword, exception block, and deprecated cleanup method.

Strings are immutable in Java so that they remain safe, predictable, and reusable. Once a `String` object is created, its value cannot be changed.

Immutability helps with security, thread safety, string pooling, and stable hash codes. In interviews, a short strong answer is: String immutability improves safety, sharing, and performance.

The String pool is a special memory area where Java stores string literals so identical literal values can be reused instead of creating separate objects again and again. This saves memory and improves reuse.

For example, two identical string literals usually point to the same pooled object. In interviews, explain that the pool mainly applies to string literals and interned strings, not to every `new String(...)` object automatically.

`String` is immutable, so every change creates a new object. `StringBuilder` is mutable and is preferred for single-threaded string modifications. `StringBuffer` is also mutable, but its methods are synchronized, so it is thread-safe with extra overhead.

In interviews, the easiest way to compare them is: `String` for fixed text, `StringBuilder` for fast modifications, and `StringBuffer` when synchronized mutable operations are needed.

For strings, `==` checks whether two references point to the same object. `equals()` checks whether the actual string content is the same.

This question is very common because string literals may sometimes make `==` look correct due to the string pool. In interviews, always say reference comparison versus content comparison.

You should prefer `StringBuilder` when multiple string changes are needed in a single-threaded or non-shared context. It is usually faster because it does not pay the cost of synchronization.

Use `StringBuffer` only when you specifically need synchronized mutable string operations. In interviews, the main comparison is performance versus thread safety.

String is commonly used as a `HashMap` key because it is immutable, so its hash code and logical value stay stable after creation. That makes lookup behavior safe and predictable.

If a mutable object used as a key changes after insertion, map behavior can break. In interviews, say that immutability is the biggest reason strings make reliable map keys.

When Java sees repeated string concatenation, especially inside expressions, the compiler often uses `StringBuilder` behind the scenes. This is done because directly creating many new immutable `String` objects would be inefficient.

In interviews, mention that simple concatenation is fine for small cases, but repeated concatenation in loops should usually use `StringBuilder` directly for better performance.

The `intern()` method returns a canonical representation of a string from the string pool. If the same value already exists in the pool, the pooled reference is returned instead of keeping a separate copy.

This is mainly asked in interviews to test understanding of the string pool. A simple answer is: `intern()` links a string value to its pooled version.

A `char[]` can be manually cleared after use, but a `String` is immutable and may stay in memory until garbage collection happens. That makes `char[]` safer for sensitive temporary data such as passwords.

This is mainly a security-focused interview question. The important idea is not performance, but the ability to remove sensitive data sooner.

Checked exceptions are checked by the compiler, so the programmer must handle them or declare them using `throws`. Unchecked exceptions are runtime exceptions and do not require compile-time handling.

Examples of checked exceptions include `IOException`, while `NullPointerException` and `ArithmeticException` are unchecked. In interviews, compare them by compiler requirement and typical cause.

`throw` is used to actually throw a specific exception object from code. `throws` is used in the method signature to declare that a method may pass certain exceptions to the caller.

In interviews, a very clear short answer is: `throw` is used inside the method body, while `throws` is used in the method declaration.

`try` contains code that may throw an exception. `catch` handles a matching exception. `finally` contains cleanup code that usually runs whether an exception happens or not.

This is one of the most basic Java exception questions. In interviews, mention that `finally` is commonly used for cleanup work such as closing resources if try-with-resources is not being used.

Try-with-resources is a Java feature that automatically closes resources such as files, streams, or database-related objects when the block finishes. It reduces manual cleanup code and makes resource handling safer.

The resource must implement `AutoCloseable`. In interviews, the main benefit to mention is automatic and cleaner resource management.

A custom exception is created by extending `Exception` for a checked exception or `RuntimeException` for an unchecked exception. This is useful when the application needs domain-specific error meaning.

In interviews, explain not only how to create it, but why: custom exceptions make business or domain errors easier to understand and handle clearly.

If `finally` also contains a `return`, that return will override the return from the `try` block. Because of this, placing `return` inside `finally` is considered bad practice.

This question is often asked to test Java exception-flow understanding. In interviews, say clearly that `finally` can override the earlier return and make code harder to reason about.

Catch blocks must be ordered from more specific exceptions to more general ones. If a general catch block comes first, the later specific one becomes unreachable and the code will not compile.

For example, `Exception` should not come before `IOException` if both are being caught. In interviews, this is a rule-based question, so answer directly and give that unreachable-code reason.

`Exception` represents conditions that applications may reasonably catch or recover from. `Error` represents serious problems, usually from the JVM or system environment, and applications normally should not try to handle them.

For example, `OutOfMemoryError` is an `Error`, while `IOException` is an `Exception`. In interviews, the important point is recoverable application problem versus serious system-level problem.

`Collection` is the root interface for most group-based data structures such as `List` and `Set`. `Collections` is a utility class that provides helper methods like sorting and searching. `Map` stores key-value pairs and is not a subtype of `Collection`.

This is a common confusion question because the names look very similar. In interviews, separate them as interface, utility class, and separate key-value hierarchy.

`List` stores ordered elements and allows duplicates. `Set` stores unique elements and usually does not allow duplicates. `Map` stores key-value pairs and uses keys to look up values.

This is a very common interview starter for Java collections. A strong short summary is: `List` for order, `Set` for uniqueness, and `Map` for key-value access.

`ArrayList` is usually better for fast random access because it is backed by a dynamic array. `LinkedList` is better suited when frequent insertions or deletions in the middle are more important than indexed access.

In practice, `ArrayList` is used more often for general cases. In interviews, compare them using internal structure, indexing speed, and insertion/deletion behavior.

`HashMap` stores data using key-value pairs and uses the key's hash code to find a bucket where the entry should be stored. If multiple keys land in the same bucket, collision-handling logic is used.

At interview level, you do not always need every internal detail. A solid answer is: `HashMap` uses hashing for near-fast access, and collisions are handled inside the bucket structure.

`HashMap` is generally preferred in modern Java because it is not synchronized and allows one null key and multiple null values. `Hashtable` is an older synchronized class and does not allow null keys or null values.

In interviews, the main comparison points are synchronization, null handling, and modern usage. Most real code uses `HashMap` unless old APIs or very specific cases require `Hashtable`.

`HashSet` stores unique elements without maintaining sorted order and usually gives faster average performance. `TreeSet` stores unique elements in sorted order but usually has more overhead because it maintains ordering.

In interviews, compare them using ordering, internal behavior, and performance trade-off. A simple line is: use `HashSet` for fast uniqueness, and `TreeSet` when sorted uniqueness is needed.

`Iterator` can move only forward and works for many collection types. `ListIterator` works only with lists, but it can move both forward and backward and can also modify elements more flexibly during iteration.

In interviews, the main points are direction support and list-specific capability. `ListIterator` is richer, but it is not available for all collection types.

Fail-fast iterators usually throw `ConcurrentModificationException` if the collection is structurally changed during iteration. Fail-safe style iteration works on a separate copy or a safer concurrent structure, so it avoids failing in the same way.

This question checks collection behavior understanding. In interviews, it is enough to say that fail-fast detects unsafe modification quickly, while fail-safe avoids direct iteration over the changing original structure.

`Comparable` defines a natural ordering inside the class itself through `compareTo()`. `Comparator` defines external custom ordering through a separate comparison object.

In interviews, the easiest memory trick is: `Comparable` is internal default ordering, and `Comparator` is external custom ordering. `Comparator` is especially useful when one class may need multiple sorting rules.

Generics allow classes, interfaces, and methods to work with types in a safer and reusable way. They improve type safety and reduce the need for manual casting.

For example, `List<String>` clearly states what kind of elements the list should hold. In interviews, the main benefits to mention are compile-time type checking and cleaner code.

Type erasure means generic type information is mainly used by the compiler during compilation and is removed or replaced with bounds in the generated bytecode. Because of this, generic type details are not fully available at runtime in the same way they appear in source code.

This is why some operations with generics are restricted, such as creating arrays of parameterized types. In interviews, a short answer is: generics give compile-time safety, but type parameters are mostly erased at runtime.

`? extends T` is used when you mainly want to read values as type `T` from a structure. `? super T` is used when you mainly want to write values of type `T` into a structure.

A common rule used in interviews is PECS: Producer Extends, Consumer Super. It is a simple memory trick that makes wildcard usage easier to explain.

A raw type means using a generic class without specifying its type parameter, such as using `List` instead of `List<String>`. It should be avoided because it removes compile-time type safety and can lead to runtime casting problems.

Raw types mostly remain for backward compatibility with older Java code. In interviews, say that generics are preferred because they catch type mistakes earlier.

`start()` creates a new thread of execution and then calls `run()` internally on that new thread. Calling `run()` directly behaves like a normal method call and does not start a new thread.

This is one of the most common Java threading interview questions. The main difference is new thread creation versus normal method execution in the current thread.

`sleep()` pauses the current thread for a given time without releasing any monitor lock it holds. `wait()` is used for inter-thread communication and releases the monitor lock while waiting.

Another key difference is that `wait()` must be called inside synchronized context on an object monitor, while `sleep()` belongs to the `Thread` class. In interviews, compare them using lock behavior and purpose.

The `synchronized` keyword is used to control access to shared code or data so that only one thread can execute the protected section at a time for the same monitor. It helps prevent race conditions in multithreaded code.

It can be applied to methods or blocks. In interviews, say that `synchronized` provides mutual exclusion and visibility guarantees for the protected section.

The `volatile` keyword tells Java that a variable's latest value should be read from main memory and written back directly, instead of allowing threads to keep stale cached copies. It is mainly used for visibility, not for making compound operations atomic.

This is an important interview distinction: `volatile` helps one thread see changes made by another thread quickly, but it does not replace synchronization for operations like incrementing a counter safely.

User threads keep the JVM alive while they are running. Daemon threads are background helper threads, and the JVM can exit when only daemon threads remain.

Daemon threads are often used for support tasks, not essential main application work. In interviews, the short line is: user threads keep the app alive, daemon threads do not.

Implementing `Runnable` is often preferred because it separates task logic from thread management and keeps inheritance free for some other class if needed. It also gives more design flexibility.

In interviews, say that Java supports single inheritance, so using `Runnable` is usually cleaner and more reusable than extending `Thread` directly.

A lambda expression is a short way to provide the implementation of a functional interface. It makes code more concise when only one abstract method needs to be implemented.

Lambdas are commonly used with functional interfaces, collections, and streams. In interviews, explain that lambdas reduce boilerplate for small behavior definitions.

An enum is a special Java type used to represent a fixed set of named constants. It is useful when only a known limited set of values should be allowed, such as status, day, or role values.

Enums are safer and clearer than using plain integer or string constants. In interviews, mention readability, type safety, and fixed valid values.

`Optional` is a container type used to represent the possible presence or absence of a value explicitly. Using `null` directly is more error-prone because it can easily lead to `NullPointerException` if checks are missed.

In interviews, the best answer is that `Optional` makes absence explicit in the API, but it should be used thoughtfully and not everywhere without reason.

The Stream API lets you process collections of data in a more declarative and pipeline-based style. It is useful for filtering, mapping, sorting, and collecting data in a cleaner way.

Streams focus on what operation should happen, not just how to loop manually. In interviews, say that streams improve readability for data-processing pipelines, though they should be used where they actually make the code clearer.