100 Core Java Interview Questions and Answers

javac compiles source code to bytecode, not machine code. Bytecode runs on any operating system that has a JVM. The JVM itself is platform-specific; your .class files are not. That is "write once, run anywhere". Revise: Bytecode and Platform Independence.

No. Java has primitive types (int, double and so on) that are not objects, and static members that belong to no object. Wrapper classes and autoboxing let primitives act like objects when needed. Revise: OOPs Concepts in Java.

public so the JVM can call it from outside the class; static so it can be called without creating an object; void because nothing is returned to the JVM (use System.exit(code) to return a status). Since Java 25, the launcher also accepts an instance void main() in compact source files. Revise: The Main Method in Java.

Yes, like any method. The JVM still starts the program from the standard main(String[] args) signature; the other overloads are just ordinary methods. Revise: The Main Method in Java.

byte 1 byte, short 2, int 4, long 8, float 4, double 8, char 2 (a UTF-16 code unit), and boolean, whose size the specification doesn't fix (in practice 1 byte in arrays). Revise: Data Types in Java.

Local variables live inside a method, on the stack, and have no default value. Instance variables belong to each object, live on the heap and get default values. Static variables belong to the class: one copy shared by all objects. Revise: Java Variables.

int is a primitive holding a value; it can't be null. Integer is an object (a wrapper class): it can be null, can be stored in collections, and has utility methods. Integer.valueOf caches values from −128 to 127. Revise: Wrapper Classes in Java.

Autoboxing is the automatic conversion between primitives and wrappers (int to Integer and back). The dangers: unboxing a null throws NullPointerException; comparing wrappers with == compares references; and boxing in hot loops creates garbage. Revise: Autoboxing and Unboxing in Java.

break exits the loop (or switch) completely. continue skips the rest of the current iteration and moves on to the next one. Both can take a label to target an outer loop. Revise: Java Break Statement and Java Continue Statement.

It can be private (used for singletons, factories and utility classes). It can't be final, static or abstract: constructors aren't inherited, so these modifiers make no sense. Revise: Private Constructors.

Only when the class declares no constructor at all. The compiler then adds a public no-argument constructor that calls super(). Declaring any constructor removes it. Revise: Constructors in Java.

this refers to the current object: use it to reach its fields or call another constructor of the same class (this(...)). super refers to the parent part of the object: use it to call a parent method or a parent constructor (super(...)). Revise: Java This Keyword and Java Super Keyword.

No. Overloads must differ in their parameter list (number, types or order). Changing only the return type is a compile error, because a call like m(); would be ambiguous. Revise: Method Overloading in Java.

Not directly. A static method has no this, so there is no object whose fields it could read. It can use instance variables only through an object reference that it is given or creates. Revise: Static Methods vs Instance Methods.

No. final on a reference means the variable can't point to a different object. The object itself can still change: final List<String> list can still have items added. Revise: Java Final Keyword.

private (same class only), default with no keyword (same package), protected (same package plus subclasses) and public (everywhere). Use the most restrictive one that works. Revise: Access Modifiers in Java.

A package is a namespace that groups related classes, matching a folder structure. It avoids name clashes (com.shop.model.Order vs com.bank.Order), controls access through package-private visibility, and keeps code organized. Revise: Packages in Java.

Single, multilevel and hierarchical. Multiple inheritance of classes is not allowed (it would create the diamond problem), but a class can implement many interfaces. Revise: Types of Inheritance.

A contract: a set of methods that implementing classes promise to provide. It can also hold constants and default, static and private methods, but no instance state. It lets unrelated classes be used through one type. Revise: Interfaces in Java.

Keeping an object's data private and exposing only methods that keep it valid. For example, a BankAccount has a private balance and deposit/withdraw methods that reject invalid amounts, rather than a public field anyone can set. Revise: Encapsulation in Java.

String is immutable. StringBuilder is mutable and fast, but not thread-safe: use it for building strings in one thread. StringBuffer is mutable and synchronized: thread-safe but slower, and rarely needed today. Revise: Difference Between String and StringBuffer.

a.equals(b) for exact content, a.equalsIgnoreCase(b) to ignore case, and a.compareTo(b) (or compareToIgnoreCase) for ordering, which returns a negative, zero or positive number. Revise: String Comparison in Java.

No; an array's length is fixed. To "grow" one, you create a bigger array and copy (Arrays.copyOf). That is exactly what ArrayList does for you internally. Revise: Copying and Cloning Arrays.

The first: using an index below 0 or at or above length. The second: using a null reference as if it pointed to an object (calling a method, reading a field, or unboxing it). Both are unchecked exceptions that usually mean a bug. Revise: Common Exceptions in Java.

Both extend Throwable. An Exception is a condition an application may reasonably catch and handle. An Error (such as OutOfMemoryError or StackOverflowError) is a serious JVM-level problem that applications usually shouldn't try to handle. Revise: Exception Hierarchy in Java.

It declares in a method signature which checked exceptions the method may pass on to its caller, for example void load() throws IOException. The caller must then handle or declare them. throw (without the s) actually throws an exception. Revise: Difference Between Throw and Throws.

Yes: try-finally, or try-with-resources, which needs neither catch nor finally. Any exception then propagates to the caller after cleanup. Revise: Try-With-Resources in Java.

parseInt returns a primitive int. valueOf returns an Integer object, reusing cached objects for −128 to 127. Use parseInt when you need a number for arithmetic. Revise: Integer.parseInt() vs Integer.valueOf().

It checks whether an object is an instance of a type (class, subclass or interface), and returns false for null. Since Java 16 it can also bind a variable: if (shape instanceof Circle c) { c.radius(); }. Revise: Java Instanceof and Pattern Matching.

Enums are type-safe (you can't pass 42 where a Status is expected), readable when printed, work in switch statements, and can have fields, methods and constructors. EnumSet and EnumMap are also very fast. Revise: Enums in Java.

equals, hashCode, toString, getClass, clone, wait (3 overloads), notify, notifyAll, and the deprecated finalize. Every class inherits them. Revise: Object Class in Java.

No. System.gc() is only a hint that the JVM may ignore. The GC runs when the JVM decides. If you feel you need to force it, there is usually a design or memory problem to fix instead. Revise: Garbage Collection in Java.

A List is ordered and allows duplicates (access by index). A Set holds no duplicates. A Map stores key-value pairs with unique keys. Map does not extend Collection. Revise: Collections in Java.

A short way to write an implementation of a functional interface (an interface with one abstract method): (a, b) -> a + b. It lets you pass behavior as data, for example to sort, filter or forEach. Revise: Lambda Expressions in Java.

Yes. var only asks the compiler to infer the type from the initializer at compile time. The variable still has a fixed type and can't later hold a different type. It works only for local variables. Revise: Local Variable Type Inference.

It's a collision: both entries go into the same bucket, chained in a list (or a tree once the bucket is large). On get, the map finds the bucket by hash and then uses equals to pick the right key. Many collisions make lookups slower, which is why a good hashCode matters. Revise: HashMap Internal Working.

The bucket is chosen from the key's hash code at insertion time. If a field used in hashCode changes afterwards, lookups search the wrong bucket and the entry becomes unreachable: a silent bug and a memory leak. String, wrappers and records make good keys. Revise: Object Equality and Hash Codes in Java.

It is backed by a HashMap: each element is stored as a key, with one shared dummy object as the value. So add, contains and remove are O(1) on average, and uniqueness depends on equals and hashCode. Revise: HashSet Internal Working.

HashMap: fastest, no order. LinkedHashMap: keeps insertion order (or access order, which is useful for LRU caches). TreeMap: keeps keys sorted, O(log n), with range methods such as headMap, ceilingKey and floorEntry. Revise: Choosing the Right Collection.

A list built with new ArrayList<>() starts with an empty array and allocates capacity 10 on the first add. When it is full, it grows to about 1.5× (old + old >> 1) and copies the elements with Arrays.copyOf. Pass an initial capacity when you know the size, to avoid repeated copying. Revise: ArrayList Internal Working.

Use list.removeIf(x -> condition), or an explicit Iterator and its remove() method. Calling list.remove(...) inside a for-each loop triggers ConcurrentModificationException. Revise: ConcurrentModificationException in Java.

unmodifiableList returns a read-only view: changes to the original list still show through it. List.copyOf makes an independent, truly immutable copy (and rejects null elements). Revise: Unmodifiable vs Immutable Collections.

employees.sort(Comparator.comparing(Employee::department)
        .thenComparing(Employee::salary, Comparator.reverseOrder()));

Chain the comparators instead of writing one long compare method. Revise: Comparator Chaining in Java.

Arrays.asList is a fixed-size view over the array: set works and writes through to the array, add/remove throw, and null is allowed. List.of is fully immutable and rejects null. Revise: Arrays.asList vs List.of.

No. It is a binary heap, so only the head is guaranteed to be the smallest (by natural order or comparator). To get elements in order, call poll() repeatedly. offer and poll are O(log n). Revise: Queue Interface and PriorityQueue in Java.

An overriding method may throw fewer or narrower checked exceptions than the parent method, but not new or broader ones. It may throw any unchecked exceptions. This keeps callers that use the parent type safe. Revise: Exception Handling with Method Overriding.

Resources close in reverse order of declaration. If the body throws and close() also throws, the body's exception is the one thrown, and the close exception is attached as a suppressed exception (getSuppressed()). Revise: Suppressed Exceptions in Java.

Its return overrides any value returned from try or catch, and silently discards any exception that was being thrown. Never return from finally. Revise: Finally Block in Java.

Wrapping a low-level exception in a higher-level one while keeping the original: throw new OrderException("Payment failed", e);. The stack trace then shows "Caused by: …", so the root cause isn't lost. Revise: Chained Exceptions in Java.

If it were, you could write List<Object> objs = strings; objs.add(42); and break the list of strings. Generics are invariant to prevent this. Use List<? extends Object> for read-only access. Revise: Generics in Java.

A type parameter restricted to a type and its subtypes, so you can call that type's methods: <T extends Comparable<T>> T max(List<T> items) can use compareTo. Multiple bounds use &: <T extends Number & Comparable<T>>. Revise: Bounded Type Parameters in Java.

Arrays check element types at runtime, but because of erasure T is unknown at runtime, so the check would be unsafe. Use a List<T>, or Array.newInstance(type, n) with a Class<T> argument. Revise: Restrictions of Generics in Java.

An interface with exactly one abstract method, so lambdas can implement it. It can also have any number of default and static methods. @FunctionalInterface makes the compiler check the rule. Revise: Functional Interfaces in Java.

Static (Integer::parseInt), bound instance (System.out::println), unbound instance where the first argument becomes the receiver (String::length), and constructor (ArrayList::new). Revise: Method References in Java.

A local variable that is never reassigned after initialization. Lambdas capture a copy of local variables, so Java requires that they don't change; otherwise the lambda and the method would see different values. Revise: Effectively Final Variables and Lambda Capture.

reduce combines elements into one value using immutable operations (sum, max). collect is a mutable reduction into a container such as a list, map or StringBuilder. For grouping or building collections, use collect. Revise: Collectors Class in Java.

Map<String, Long> perDept = employees.stream()
        .collect(Collectors.groupingBy(Employee::department,
                Collectors.counting()));

Revise: groupingBy, partitioningBy, toMap and Joining.

It throws IllegalStateException. Pass a merge function to decide what to do, for example toMap(Employee::id, e -> e, (a, b) -> a) to keep the first one. Revise: groupingBy, partitioningBy, toMap and Joining.

findFirst returns the first element in encounter order. findAny may return any element, which is faster in parallel streams. On sequential streams they usually behave the same. Revise: Parallel Streams in Java.

A default method is inherited by implementing classes and can be overridden. A static interface method is not inherited: you call it as InterfaceName.method(). It is useful for factory and helper methods. Revise: Default, Static and Private Methods in Interfaces.

Subclass constructors call it through super(...) to initialize the abstract class's own fields and enforce its rules. Every object of a subclass includes the abstract parent's part. Revise: Abstract Classes and Abstract Methods.

A shallow copy copies field values, so referenced objects are shared. A deep copy also copies the referenced objects. clone() is shallow by default and awkward to use correctly; prefer copy constructors or static factory methods. Revise: Object Cloning in Java.

double can't represent most decimal fractions exactly, so sums drift. new BigDecimal(0.1) captures that binary approximation (0.1000000000000000055…); the String constructor or BigDecimal.valueOf(0.1) gives exactly 0.1. Compare with compareTo, because equals also compares scale (2.0 ≠ 2.00). Revise: BigInteger and BigDecimal in Java.

It returns the canonical copy of the string from the String pool, adding it if needed. It can save memory when many equal strings are created at runtime (for example, repeated values parsed from a file), but adds lookup cost. Use it rarely, and measure first. Revise: String Intern Method in Java.

It is a version number for a serializable class. When deserializing, the stored and current values must match, or you get InvalidClassException. Declare it explicitly; otherwise the JVM computes one from the class structure, and even small changes break old data. Revise: Serializable Interface and serialVersionUID.

Neither is written. static fields belong to the class, not the object. transient fields are skipped on purpose (for passwords or caches) and come back with default values (null, 0, false). Revise: Transient Keyword in Java.

An Instant, meaning a point in time in UTC (or OffsetDateTime). Convert to ZonedDateTime only for display in a user's time zone. LocalDateTime has no zone, so it can't represent an exact moment. Revise: ZonedDateTime, ZoneId and Instant.

NEW, RUNNABLE, BLOCKED (waiting for a monitor lock), WAITING (wait, join, park), TIMED_WAITING (sleep, waits with a timeout) and TERMINATED, as listed in Thread.State. Revise: Thread Life Cycle in Java.

Ask it to stop with thread.interrupt(). The task checks Thread.currentThread().isInterrupted(), or catches InterruptedException, cleans up, and exits (or restores the flag with Thread.currentThread().interrupt()). Thread.stop() was unsafe and no longer works in modern Java. Revise: Interrupting a Thread in Java.

A background thread that doesn't keep the JVM alive: the JVM exits when only daemon threads remain. Set it with setDaemon(true) before start(). Don't use daemon threads for work that must finish, such as writing files. Revise: Daemon Threads in Java.

If action A happens-before action B, B is guaranteed to see A's effects. Rules include: releasing a monitor happens-before the next time another thread acquires that same monitor; a volatile write happens-before later reads of that field; Thread.start() happens-before the started thread's actions; a thread's actions happen-before another thread's join() returns. Without such an edge, a thread may see stale or reordered values. Revise: Java Memory Model and Happens-Before.

private static volatile Config instance;
static Config get() {
    if (instance == null) {
        synchronized (Config.class) {
            if (instance == null) instance = new Config();
        }
    }
    return instance;
}

Without volatile, the write of the reference can be reordered before the constructor finishes, so another thread may see a half-built object. The holder idiom or an enum singleton avoid the problem entirely. Revise: Thread-Safe Singleton in Java.

It uses CAS to fill empty bins and locks only the first node of a bin for other updates, so threads working on different bins don't block each other; reads are mostly lock-free. putIfAbsent, compute, computeIfAbsent and merge are atomic per key. A separate get followed by put is not. Keep the functions you pass short, and never let them modify the map. Revise: Concurrent Collections in Java.

thenApply transforms the result (like map). thenCompose chains a step that itself returns a CompletableFuture (like flatMap, which avoids nested futures). thenCombine joins the results of two independent futures. For errors, exceptionally recovers and handle sees both the result and the exception. Revise: CompletableFuture in Java.

With submit, the exception is captured in the Future and only appears when you call get(), wrapped in ExecutionException. If you never call get(), it is silently lost. With execute, it reaches the thread's uncaught-exception handler and is usually logged. Revise: Callable and Future in Java.

For CPU-bound work, about the number of cores (Runtime.getRuntime().availableProcessors()). For I/O-bound work, more: roughly cores × (1 + wait time / compute time). Use bounded queues, measure under real load, and for heavy blocking I/O consider virtual threads instead. Revise: Types of Thread Pools in Java.

A read-write lock lets many readers in at once but only one writer, which suits data that is read often and written rarely. StampedLock adds optimistic reads: read without locking, then validate(stamp) and retry under a real lock if a write happened. It is faster but not reentrant, and harder to use correctly. Revise: Locks in Java.

Pool threads live for a long time, so values stored in a ThreadLocal stay alive after the task ends, and can even leak into the next task that runs on that thread. Always call remove() in a finally block. In application servers, this can also keep whole class loaders in memory. Revise: ThreadLocal in Java.

A CountDownLatch lets threads wait until N events have happened; it is one-shot. A CyclicBarrier makes N threads wait for each other at a meeting point, and can be reused. A Semaphore limits how many threads can use a resource at the same time (permits). Revise: Synchronizers in Java.

Each worker has its own task deque; idle workers steal tasks from the tail of busy workers' deques, which balances divide-and-conquer work. Parallel streams and CompletableFuture's *Async methods without an executor use ForkJoinPool.commonPool(). Blocking calls there can starve the whole application, so pass your own executor for I/O. Revise: Fork/Join Framework in Java.

For CPU-bound work (they add no cores); when you would pool them (create one per task instead); with large per-thread ThreadLocal caches (millions of threads means millions of copies); and around long native calls, which pin the carrier thread. Use them for many concurrent blocking I/O tasks. Revise: Virtual Thread Best Practices.

Scoped values (final in Java 25) share immutable context, such as a request ID or user, with called code and child threads for a bounded scope; they are cheaper and safer than ThreadLocal. Structured concurrency (a preview in Java 25) treats a group of subtasks as one unit: if one fails, the others are canceled, and errors and cancellation propagate cleanly. Revise: Scoped Values in Java and Structured Concurrency in Java.

Loading (find the bytes, create the Class), linking (verify, prepare static fields with defaults, resolve symbols), then initialization (run static initializers). A class is initialized on first active use: creating an instance, calling a static method, reading a non-constant static field, reflection, initializing a subclass, or being the main class. Revise: Class Loaders in Java.

ClassNotFoundException is a checked exception thrown when code loads a class by name (Class.forName, a class loader) and it isn't found. NoClassDefFoundError is an error thrown when a class that existed at compile time is missing at runtime, or failed its static initialization earlier. Check the classpath, dependency versions and static initializers. Revise: Class Loaders in Java.

Java heap space (heap full: a leak, or the heap is too small); Metaspace (too many classes, often a class loader leak); GC overhead limit exceeded (GC runs constantly but frees almost nothing); unable to create native thread (OS thread limit); Direct buffer memory (off-heap buffers). Each one needs a different fix. Revise: OutOfMemoryError Types and Causes.

Find the hot OS threads (top -H -p <pid>), convert their IDs to hex, take a thread dump (jcmd <pid> Thread.print or jstack), and match the nid values to see which code is running. Also check GC logs, because constant GC looks like high CPU. Use JFR or a profiler for a full picture. Revise: Heap Dumps and Thread Dumps.

New objects go into Eden. Minor GCs copy live objects to survivor spaces, and objects that survive several collections are promoted to the old generation. This works because most objects die young. G1 divides the heap into equal regions, collects young regions, and runs mixed collections that also clean the old regions with the most garbage, aiming for a pause-time target. Revise: How Garbage Collection Works.

Soft: memory-sensitive caches, cleared before an OutOfMemoryError. Weak: data attached to objects without keeping them alive (WeakHashMap keys, listeners), cleared at the next GC. Phantom: cleanup after an object is gone, which is what Cleaner uses instead of finalize. Revise: Strong, Weak, Soft and Phantom References.

Code starts in the interpreter while the JVM collects profiles. Hot methods are compiled by C1, then optimized by C2 using real runtime data (inlining, escape analysis, removing unneeded checks). Class loading and caches also warm up. This is why benchmarks need warm-up, and why AOT caching (Java 24–25) helps startup time. Revise: Tiered Compilation in Java.

It can validate in a compact constructor, add methods and static fields, implement interfaces and be generic. It can't extend a class (it implicitly extends Record and is final), declare instance fields, or have setters. It is only shallowly immutable, so copy mutable components. Revise: Records in Java.

A sealed hierarchy lists every subtype, so a switch over it can be checked for exhaustiveness with no default. When you add a new subtype, the compiler shows you every switch that must handle it. This lets you model data cleanly, for example sealed interface Payment permits Card, Upi, Wallet. Revise: Exhaustive Switch with Sealed Types.

You can't overload m(List<String>) and m(List<Integer>), because both erase to m(List). You can't write obj instanceof List<String> or new T(). A third: List<String>.class doesn't exist; there is only List.class. Revise: Type Erasure in Java.

Its signature is copy(List<? super T> dest, List<? extends T> src). The source produces T values, so it uses extends; the destination consumes them, so it uses super. That lets you copy a List<Integer> into a List<Number>. Revise: PECS Rule in Java Generics.

It is slower than direct calls (access checks, boxing, harder for the JIT), although Java 18 rebuilt core reflection on method handles. It skips compile-time checks, so errors appear at runtime. Under the module system, setAccessible(true) on a package that isn't opened throws InaccessibleObjectException. Use MethodHandle for hot paths. Revise: Reflection API in Java.

Proxy.newProxyInstance creates a class at runtime that implements the given interfaces and sends every call to an InvocationHandler. Frameworks use proxies for transactions, logging, security and remote calls. Spring uses JDK proxies for interfaces, and generated subclasses (via bytecode libraries) for classes. Revise: Dynamic Proxies in Java.

If ColorPoint extends Point adds a color, using instanceof in equals breaks symmetry: a point can equal a colored point but not the other way round. Options: compare with getClass() (strict), use composition instead of inheritance, or make value classes final (records are final by design). Revise: Object Equality and Hash Codes in Java.

A String caches its hash code in a field after the first calculation, because it is immutable. If many keys collide (even deliberately, in a hash-flooding attack), Java 8+ HashMap turns large buckets into red-black trees, so the worst case is O(log n) instead of O(n) (most effective when keys are Comparable). Revise: HashMap Internal Working.

Every write copies the whole array, and iterators work on a snapshot, so reads need no locks and never throw ConcurrentModificationException. It is great for read-mostly lists such as event listeners, and terrible for lists that change often. Revise: Concurrent Collections in Java.

Not necessarily. The identity hash code is generated on first request (HotSpot uses a thread-local random scheme by default) and stored in the object header, so it stays stable even though GC moves objects. Two different objects can even share an identity hash code. Revise: Object Memory Layout in Java.

1. If Order isn't initialized yet, the JVM loads, links and initializes it (static blocks run).
2. Memory is allocated, usually by bumping a pointer in the thread's TLAB in Eden (fast and lock-free).
3. The memory is zeroed, so fields get default values.
4. The object header is set (mark word and class pointer).
5. The constructor chain runs (<init>, from Object down to Order, with field initializers and instance blocks).
6. The reference is returned. Escape analysis may even remove the allocation if the object never leaves the method.

Revise: Order of Initialization and Object Memory Layout in Java.