150+ Killer Core Java Interview Questions and Answers (Crack Any Job)

Preparing for a Java interview can feel overwhelming. Companies from startups to FAANG expect developers to master Core Java fundamentals, understand OOP principles, handle collections, generics, concurrency, and explain JVM internals. This mega-guide covers 150+ Core Java Interview Questions and Answers, carefully structured for freshers, mid-level, and senior developers.

You’ll find:

Basics for freshers (OOP, strings, keywords)
Collections, generics, concurrency (3-5 years)
JVM, GC tuning, performance (5-10 years)
Scenario-based and advanced Java 8+ topics
FAQs and a downloadable Core Java interview questions PDF

By the end, you’ll have a complete Core Java interview cheat sheet to help you crack any job interview.

Table of Contents

Quick Answers

What is the JVM?

The Java Virtual Machine loads bytecode, verifies it, JIT‑compiles hot paths, manages memory (heap/stack), and runs your program independently of the underlying OS/CPU.

JDK vs JRE vs JVM?

JDK = tools + compiler + JRE; JRE = JVM + core libraries to run Java; JVM = runtime engine that executes bytecode.

Checked vs unchecked exceptions?

Checked (e.g., IOException) must be declared/handled at compile time; unchecked (RuntimeException and its children) represent programming errors and need not be declared.

final vs finally vs finalize?

final makes variables constants/methods non‑overridable/classes non‑extendable; finally is a try block that always runs; finalize() (deprecated) was a last‑chance GC hook-avoid.

== vs equals()?

== compares references; equals() compares logical equality. If you override equals, you must also override hashCode().

Java Basics & OOP (Freshers)

What are the OOP principles in Java?

Encapsulation: Wrapping data and methods together; achieved using private fields + getters/setters.
Inheritance: Code reuse using extends.
Polymorphism: One reference, many implementations (overriding/overloading).
Abstraction: Hiding details with abstract classes & interfaces.

What is the difference between a class and an object?

Class: A blueprint/template defining fields and methods.
Object: A runtime instance of a class created with new.

class Car { String model; }
Car c = new Car(); // object

Explain access modifiers in Java.

public: Accessible everywhere.
protected: Package + subclasses.
(default/package-private): Within same package.
private: Only inside class.

Abstract class vs Interface?

Abstract class: Can hold state, constructors, and partial implementations.
Interface: Contract-only; since Java 8, can have default & static methods.

Can Java support multiple inheritance?

Classes: No, avoids diamond problem.
Interfaces: Yes, via multiple interface inheritance.

What is the difference between `static` and instance members?

static: Belongs to the class, shared by all objects.
Instance members: Unique per object.

What is immutability and why is it important?

Immutable objects (like String) can’t change after creation.
Benefits: Thread-safety, safe to cache, good as map keys.

What are primitive types vs wrapper classes?

Primitives: int, double, char, etc. Stored in stack.
Wrappers: Objects (Integer, Double, etc.). Stored in heap, support null & generics.

What is autoboxing and unboxing?

Autoboxing: Primitive → wrapper.
Unboxing: Wrapper → primitive.

Integer a = 5; // autoboxing
int b = a;     // unboxing

⚠️ Pitfall: Don’t compare wrappers with ==, use equals().

What is a package in Java?

A namespace that organizes classes & avoids naming conflicts.
Maps to folder structure.

package com.example.utils;

What is the difference between `==` and `equals()`?

==: Compares memory references.
equals(): Compares logical equality (content).

Explain method overloading vs overriding.

Overloading: Same name, different parameters (compile-time).
Overriding: Subclass changes behavior of parent method (runtime).

What is the difference between `final`, `finally`, and `finalize()`?

final: Keyword (constant, non-overridable, non-inheritable).
finally: Block in try-catch that always executes.
finalize(): Deprecated cleanup method called by GC.

What is the difference between JDK, JRE, and JVM?

JDK: Tools + compiler + JRE.
JRE: JVM + libraries (to run Java apps).
JVM: Runtime engine that executes bytecode.

What is a constructor in Java?

Special method invoked during object creation.
No return type, same name as class.

class A { A() { System.out.println(\"Constructor\"); } }

What is the default constructor?

If no constructor is defined, Java provides one with no arguments.

Can constructors be inherited?

No, but subclasses call parent constructors using super().

Order of initialization in Java?

Static fields/blocks
Instance fields/blocks
Constructor

What is shadowing in Java?

When a local variable hides a class field with the same name.

class A {
  int x = 10;
  void test() {
    int x = 20; // shadows field
  }
}

Difference between `this` and `super`?

this: Refers to current object.
super: Refers to parent class members.

Strings & Core Java Basics

Why is `String` immutable in Java?

Answer:

Security: Class loaders, file paths, SQL queries, and network hosts often take String. If it were mutable, malicious code could alter them after validation.
String pool: The JVM interns string literals to a pool. Immutability guarantees that shared references never change.
Thread-safety: Immutable strings are inherently thread-safe with zero synchronization cost.
Hash caching: String caches its hash code; immutability guarantees consistency for use in HashMap/HashSet.
Implementation note: Since JDK 9, String uses a compact representation backed by a byte[] plus a coder flag (Latin-1 or UTF-16), improving memory footprint. Earlier JDKs used a char[].

`StringBuilder` vs `StringBuffer` vs `String` concatenation

Answer:

StringBuilder: Not synchronized → fastest in single-threaded code; ideal for loops.
StringBuffer: Synchronized → thread-safe but slower; legacy.
String: Immutable; using + in a loop creates many temporary objects.
Compile-time folding: "a" + "b" + "c" becomes "abc" at compile time.
Runtime concatenation: s = s + x compiles to new StringBuilder(s).append(x).toString() once per expression (still expensive in loops).
Tip: Pre-size builders if you know the size:

StringBuilder sb = new StringBuilder(1024);
for (String w : words) sb.append(w).append(' ');

`==` vs `equals()` for strings

Answer:

== compares references (same object?).
equals() compares content (same sequence of chars?).
Two equal strings in different objects: == false, equals() true.
When == can be true: Literals from the pool or when both references are the same interned instance. Prefer equals().

What is the String Pool and how does `intern()` work?

Answer:

String Pool: A JVM-managed set of unique string instances for literals and interned strings.
Since JDK 7, the pool is on the heap, not PermGen.
intern() returns a canonical representation: if the pool already has an equal string, you get that reference; otherwise, it adds one.
Use sparingly: Excessive interning can increase GC pressure. It’s helpful when you have many repeats (e.g., parsing CSV enums).

String a = new String("java");
String b = "java";
System.out.println(a == b);           // false
System.out.println(a.intern() == b);  // true

How does `substring()` work? Has its memory behavior changed?

Answer:

Historically (older JDK 6/7), substring could share the original char array, risking memory leaks by keeping a huge backing array alive.
Modern JDKs (7u6+ and 8+) copy the relevant range, avoiding this leak pattern. In JDK 9+, strings use a byte[] (compact strings), and substring takes only the needed bytes.
Takeaway: The historical leak issue is largely gone, but still avoid creating many substrings of very large strings unnecessarily.

Best way to build large strings efficiently?

Answer:

Use StringBuilder with an initial capacity.
Avoid + inside loops.
When joining known delimiters, use String.join, StringJoiner, or Collectors.joining().

List<String> names = List.of("Ada","Linus","James");
String csv = String.join(",", names); // "Ada,Linus,James"

How do you compare strings ignoring case safely (i18n pitfalls)?

Answer:

Prefer equalsIgnoreCase() for simple ASCII needs.
For locale-aware case operations, specify the locale to avoid the Turkish-I problem:

boolean eq = a.toLowerCase(Locale.ROOT).equals(b.toLowerCase(Locale.ROOT));

Avoid toLowerCase() without a Locale; results vary by default system locale.

Unicode, UTF-16, code points, and why `char` can be misleading

Answer:

Java’s char is 16-bit and represents a UTF-16 code unit, not necessarily a full Unicode character. Some characters (emoji, historic scripts) need two code units (a surrogate pair).
Use code points APIs to avoid breaking characters:

int lengthInCodePoints = str.codePointCount(0, str.length());
str.codePoints().forEach(cp -> System.out.println(Character.toChars(cp)));

When slicing, avoid splitting surrogate pairs; use offsetByCodePoints.

Encoding & decoding bytes and strings

Answer:

Always specify a charset; never rely on platform default.

byte[] data = str.getBytes(StandardCharsets.UTF_8);
String restored = new String(data, StandardCharsets.UTF_8);

Mismatched encodings cause mojibake (garbled text). Standardize on UTF-8.

Explain `String.format`, `Formatter`, and `MessageFormat`

Answer:

String.format(Locale, ...) supports C-style formats (%s, %d, %,.2f).
Formatter is the underlying streaming API.
MessageFormat is locale-aware (especially for dates/numbers); supports parameter reordering.
Performance: Formatting is slower than simple concatenation; use it where readability or i18n matters.

String s = String.format(Locale.US, "Total: $%,.2f", 12345.678); // Total: $12,345.68

What is `CharSequence` and why should you care?

Answer:

CharSequence is an interface implemented by String, StringBuilder, StringBuffer, CharBuffer, etc.
Accepting CharSequence in APIs makes them more general without copying to String.

void print(CharSequence cs) { System.out.println(cs); }

Regular expressions with `String` vs `Pattern`/`Matcher`

Answer:

String.matches(regex) requires the whole string to match and recompiles the pattern each time (slow in loops).
Prefer precompiled Pattern for repeated use and use Matcher.find() for partial matches.

Pattern p = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
Matcher m = p.matcher("Today is 2025-09-18");
System.out.println(m.find()); // true

How do text blocks work and when should you use them? (Java 15+)

Answer:

Text blocks allow multi-line string literals with """ improving readability for JSON, SQL, HTML.
They preserve newlines and handle common indentation.

String json = """
  {
    "lang": "Java",
    "year": 1995
  }
  """;

Use for embedded resources; avoid building dynamic strings with complex concatenations.

`String.join` vs `StringJoiner` vs `Collectors.joining`

Answer:

String.join(delim, elements…): simplest for arrays/iterables.
StringJoiner(delim, prefix, suffix): when you need wrappers.
Collectors.joining(delim, prefix, suffix): inside streams.

String j = new StringJoiner(", ", "[", "]")
  .add("A").add("B").add("C").toString(); // "[A, B, C]"

Trimming, blank checks, and whitespace handling (Java 11+)

Answer:

trim() removes ASCII ≤ U+0020;
strip(), stripLeading(), stripTrailing() use Unicode whitespace.
isBlank() checks if a string is empty or only whitespace.

"  \t".isBlank();          // true
" ".strip().isEmpty();     // true (NBSP handled)

String search APIs (`indexOf`, `contains`, `regionMatches`)

Answer:

contains(sub): true if indexOf(sub) >= 0.
startsWith, endsWith: quick prefix/suffix checks.
regionMatches(ignoreCase, toffset, other, ooffset, len): locale-free segment comparison (faster than copying).
Use these for performance instead of regex where possible.

Can you `switch` on strings? (Since Java 7)

Answer:

Yes. The compiler translates to a hash lookup + equals checks.
Prefer enums for closed sets; strings are fine for user input dispatch.

switch (command) {
  case "start" -> run();
  case "stop"  -> halt();
  default      -> help();
}

`String.valueOf` vs `toString` and null-safety

Answer:

String.valueOf(obj) returns "null" for null inputs; obj.toString() throws NullPointerException.
Prefer String.valueOf when logging or building messages from possibly-null references.

Repeating and indenting strings (Java 11+)

Answer:

repeat(int n) duplicates content; indent(int n) adjusts indentation; stripIndent() normalizes.

"*".repeat(5);   // "*****"
"hi\nthere".indent(2);

When should you use `intern()`? Any risks?

Answer:

Use only when you have extremely high duplication (e.g., millions of repeats of small tokens).
Risks: bloating the heap, longer GC pauses, and potential contention on the pool. Measure memory and GC before/after.

Common performance pitfalls with strings

Answer:

+ in loops → allocate many temporaries (use StringBuilder).
Unnecessary new String("literal") defeats pooling.
Regex for simple contains/startsWith → use plain APIs.
Ignoring charset → encoding bugs and extra conversions.
Excessive substring on massive inputs → many small allocations; consider StringBuilder slices or CharBuffer.

Idiomatic snippets you should know (quick wins)

// Safe equals when a might be null
Objects.equals(a, b);

// Case-insensitive comparison, locale-safe
a.equalsIgnoreCase(b); // or normalize with Locale.ROOT

// Join with delimiter
String csv = String.join(",", list);

// Fast prefix/suffix checks
if (s.startsWith("Bearer ") || s.endsWith(".java")) { /* ... */ }

// Avoid NPE in logs
log.info("User={}", String.valueOf(userId));

// Count code points (emoji-safe length)
int cps = s.codePointCount(0, s.length());

Collections & Generics (3 Years Experience)

This section is essential for mid-level interviews (3–5 years) where recruiters test your data structures, algorithmic thinking, and type-safety knowledge in Core Java.

Explain the Java Collections hierarchy.

Answer:

Core interfaces:
- Collection (root for List, Set, Queue)
- Map (separate, key-value pairs)
Common implementations:
- List: ArrayList, LinkedList, Vector (legacy)
- Set: HashSet, LinkedHashSet, TreeSet
- Queue: PriorityQueue, ArrayDeque
- Map: HashMap, LinkedHashMap, TreeMap, Hashtable (legacy)
Design principle: Use interfaces in variables/parameters (List<String> list = new ArrayList<>();) for flexibility.

Difference between `ArrayList` and `LinkedList`?

Answer:

ArrayList:
- Backed by a dynamic array.
- O(1) random access via index.
- O(n) insert/remove in the middle (shifts elements).
- Cache-friendly (good locality).
LinkedList:
- Doubly-linked nodes.
- O(1) insert/delete once you have a reference.
- O(n) to traverse for random access.
- Higher memory (extra pointers).
  Tip: Use ArrayList for most cases; LinkedList rarely outperforms in practice unless for frequent insertions at head/tail.

How does `HashMap` work internally?

Answer:

Hashing: Key’s hashCode() → bucket index (hash & (n-1) where n = table size).
Collision resolution:
- < JDK 8: Linked list in bucket.
- JDK 8+: Tree bin (red-black tree) if bucket grows beyond threshold (≥8).
Resizing: When size > load factor * capacity (default load factor = 0.75).
Equality check: First check hashCode, then equals.

Map<String, Integer> map = new HashMap<>();
map.put("Java", 25); // "Java".hashCode() determines bucket

Why must `equals()` and `hashCode()` be consistent?

Answer:

If two objects are equal, they must return the same hash.
Otherwise, retrieval from hash-based collections (HashMap, HashSet) may fail.

@Override public boolean equals(Object o) { /* compare fields */ }
@Override public int hashCode() { return Objects.hash(f1, f2); }

`HashMap` vs `Hashtable` vs `ConcurrentHashMap`?

Answer:

HashMap: Not synchronized; allows null key + values.
Hashtable: Synchronized, legacy, no null keys/values.
ConcurrentHashMap:
- Thread-safe without locking the whole map (uses bin-level/segment locking).
- Null keys/values not allowed.
- Provides atomic operations (computeIfAbsent, putIfAbsent).
  Tip: Always prefer ConcurrentHashMap for concurrent code.

Difference between `HashSet`, `LinkedHashSet`, and `TreeSet`?

Answer:

HashSet: Unordered, backed by HashMap.
LinkedHashSet: Maintains insertion order.
TreeSet: Sorted according to natural order or a Comparator.
Complexity: O(1) for HashSet, O(log n) for TreeSet.

Fail-fast vs Fail-safe iterators

Answer:

Fail-fast (default): Iterators of ArrayList, HashMap throw ConcurrentModificationException if structurally modified during iteration.
Fail-safe: Iterators of concurrent collections (CopyOnWriteArrayList, ConcurrentHashMap) work on a snapshot.
Why important in interviews? Demonstrates knowledge of concurrency guarantees.

Difference between `Comparable` and `Comparator`?

Answer:

Comparable: Defines natural order inside the class via compareTo().
Comparator: Defines external orderings, useful when multiple sort criteria exist.
Best practice: Use Comparator.comparing for flexibility.

list.sort(Comparator.comparing(Person::getAge));

Generics in Java – why and how?

Answer:

Introduced in Java 5 for type safety at compile-time.
Prevents casting errors.
Type erasure: Generics exist only at compile time; erased at runtime.

List<String> list = new ArrayList<>();
list.add("hi");
// list.add(1); // compile error

What is the PECS principle in generics?

Answer:

Producer Extends, Consumer Super.
If a structure produces T → ? extends T.
If it consumes T → ? super T.

void copy(List<? extends Number> src, List<? super Number> dest) { /* ... */ }

Why can’t you create `new T[]` in generics?

Answer:

Due to type erasure, runtime doesn’t know T’s type.
Workaround: use Array.newInstance() or collections.

@SuppressWarnings("unchecked")
T[] arr = (T[]) new Object[size];

Raw types in generics – why avoid them?

Answer:

Raw type disables type checks → risk of ClassCastException.
Always use parameterized form: List<String> not List.

What is `ConcurrentModificationException`?

Answer:

Thrown when fail-fast iterators detect concurrent structural modification.
Safe fix: Use Iterator.remove() or concurrent collections.
Example trigger:

for (String s : list) list.remove(s); // throws CME

What is `CopyOnWriteArrayList`? When to use?

Answer:

Creates a new copy of the underlying array on each write.
Iterators work on snapshots → safe under concurrent reads.
Best for: Many readers, few writers (e.g., subscriber lists).
Not good for: Heavy write operations (expensive copies).

Difference between `Vector` and `ArrayList`?

Answer:

Both dynamic arrays.
Vector: synchronized, legacy.
ArrayList: unsynchronized, modern choice.
Performance: ArrayList is faster; use Collections.synchronizedList() or CopyOnWriteArrayList if you need thread safety.

What is the difference between capacity and size?

Answer:

Capacity: How many elements the collection can hold without resizing.
Size: How many elements are currently stored.
Example: ArrayList doubles capacity when exceeded.

`WeakHashMap` vs `HashMap`?

Answer:

WeakHashMap uses weak references for keys.
Keys are eligible for GC → entries vanish automatically when key is not strongly referenced.
Useful for caches where keys shouldn’t prevent GC.

`EnumSet` and `EnumMap`

Answer:

Specialized collections for enum keys.
Highly space/time efficient (bit vectors).
Example:

EnumSet<Day> weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);

What is the difference between `HashMap` and `IdentityHashMap`?

Answer:

HashMap: Uses equals() for key equality.
IdentityHashMap: Uses == (reference equality).
Rare use cases: object identity caches.

What are bounded type parameters in generics?

Answer:

Restrict type arguments.

<T extends Number> void print(T val) { ... }

Multiple bounds: <T extends Number & Comparable<T>>.

While preparing for interviews, it’s not enough to just know Java basics. You also need a solid grasp of collections. For a deep dive, check out our 67+ Java Collections Interview Questions and Answers (2025 Guide)

Concurrency & Multithreading (5 Years Experience)

This is one of the most important areas in Core Java interviews for mid-to-senior developers – expect questions on threads, synchronization, executors, and the Java Memory Model (JMM).

What is a thread in Java?

Answer:

A thread is the smallest unit of execution in a program.
Java threads map to native OS threads (since Java 1.2+).
Each thread has its own stack, but shares heap memory with other threads.
Thread lifecycle: NEW → RUNNABLE → RUNNING → BLOCKED/WAITING → TERMINATED.

Difference between `process` and `thread`?

Answer:

Process: Independent execution unit with its own memory.
Thread: Lightweight sub-unit of a process, shares memory/resources.
Java apps usually run as one process with many threads.

What does `volatile` guarantee?

Answer:

Ensures visibility (changes to a variable are seen by all threads immediately).
Prevents certain reorderings (establishes a happens-before edge).
Does NOT provide atomicity.

volatile boolean running = true;

⚠️ Pitfall: volatile int counter++ is not atomic → use AtomicInteger instead.

How does `synchronized` work?

Answer:

Acquires a monitor lock (intrinsic lock) on an object/class.
Guarantees mutual exclusion and happens-before visibility.
Reentrant: a thread can re-acquire its own lock.

synchronized(lock) {
  // critical section
}

⚠️ Keep synchronized blocks small to reduce contention.

Deadlock: What is it and how to avoid it?

Answer:

Occurs when multiple threads wait forever for locks held by each other.
Conditions for deadlock: mutual exclusion, hold & wait, no preemption, circular wait.
Prevention strategies:
- Lock ordering
- Try-lock with timeout (ReentrantLock.tryLock())
- Avoid nested locks if possible

Difference between `Runnable`, `Callable`, and `Future`?

Answer:

Runnable: No result, no checked exceptions.
Callable: Returns result and can throw checked exceptions.
Future: Represents pending result of Callable.

ExecutorService es = Executors.newFixedThreadPool(2);
Future<Integer> f = es.submit(() -> 42);
System.out.println(f.get()); // 42

What is `CompletableFuture` and why is it better?

Answer:

Added in Java 8.
Provides async pipelines with callbacks, chaining, and composition.
Non-blocking → allows combining multiple async tasks.

CompletableFuture.supplyAsync(() -> 10)
  .thenApply(x -> x * 2)
  .thenAccept(System.out::println); // 20

Difference between thread pool types in Executors?

Answer:

newFixedThreadPool(n): Fixed number of threads.
newCachedThreadPool(): Dynamic pool; unbounded threads for short tasks.
newSingleThreadExecutor(): Single worker thread.
newScheduledThreadPool(n): Periodic/Delayed execution.
⚠️ Best practice: Don’t use raw Executors.*; instead, use ThreadPoolExecutor with custom configs.

What is the Java Memory Model (JMM)?

Answer:

Defines how threads interact through memory.
Ensures visibility and ordering of shared variable updates.
Happens-before rules:
- Lock release → lock acquire
- volatile write → volatile read
- Thread start/join boundaries
  ⚠️ Without synchronization/volatile, threads may see stale values.

What is `ThreadLocal` and when to use it?

Answer:

Provides per-thread storage.
Each thread sees its own copy of the variable.
Good for formatters, DB sessions.
⚠️ Memory leak risk in thread pools → call remove() after use.

ThreadLocal<DateFormat> tl = ThreadLocal.withInitial(
  () -> new SimpleDateFormat("yyyy-MM-dd")
);

Difference between `notify` and `notifyAll`?

Answer:

notify(): Wakes a single waiting thread.
notifyAll(): Wakes all waiting threads.
Best practice: Use notifyAll to avoid missed signals (risk of starvation with notify).

Spurious wakeups in `wait()` – why loop conditions?

Answer:

Threads waiting on wait() can wake without being notified (spurious wakeup).
Always wrap in a while loop checking condition.

synchronized(lock) {
  while (!condition) lock.wait();
}

Difference between `ReentrantLock` and `synchronized`?

Answer:

synchronized: Simpler, intrinsic lock, auto-release.
ReentrantLock: Advanced features → tryLock, fairness, condition variables.
Use ReentrantLock when fine-grained control is required.

Difference between starvation and livelock?

Answer:

Starvation: A thread never gets CPU/lock (e.g., unfair scheduling).
Livelock: Threads keep responding to each other but make no progress (they’re “too polite”).

Difference between `ForkJoinPool` and `ThreadPoolExecutor`?

Answer:

ForkJoinPool: Uses work-stealing; efficient for fine-grained parallel tasks (e.g., parallel streams).
ThreadPoolExecutor: General-purpose thread pool with queues.
Tip: Use FJP for recursive divide-and-conquer; TPE for normal tasks.

What is `CountDownLatch` vs `CyclicBarrier`?

Answer:

CountDownLatch: One-time latch; wait until a count reaches zero.
CyclicBarrier: Reusable barrier; all threads wait until a threshold is reached.

Difference between `Semaphore` and `Exchanger`?

Answer:

Semaphore: Controls access with permits (e.g., limit 3 concurrent DB connections).
Exchanger: Pairs of threads swap data rendezvous-style.

What is a daemon thread in Java?

Answer:

Background service thread (e.g., GC).
JVM exits when only daemon threads remain.
Marked with t.setDaemon(true).
⚠️ Don’t use for critical tasks; no guaranteed cleanup.

Explain false sharing.

Answer:

Occurs when multiple threads modify variables in the same cache line → CPU cache contention.
Fix: Padding (@Contended annotation) or reorganizing memory layout.

Virtual threads (Project Loom, Java 21+)

Answer:

Lightweight, user-mode threads scheduled by JVM.
Thousands of virtual threads can run on a few OS threads.
Write blocking-style code with async scalability.
Eliminates much of the complexity of callbacks/futures.

JVM, Class Loading & Garbage Collection (5–10 Years Experience)

This is where senior Java interview questions come in – JVM internals, class loading, garbage collectors, and performance tuning.

What are the main memory areas in JVM?

Answer:

Heap: Stores objects; split into Young Gen (Eden + Survivor spaces) and Old Gen.
Stack: Stores local variables and method frames (per-thread).
Metaspace (since Java 8): Stores class metadata (replaces PermGen).
Code Cache: Stores JIT compiled bytecode.
Native memory: Used by direct buffers, threads, JNI.

⚠️ Interview tip: JVM tuning usually means adjusting heap generations and GC strategies.

What are the phases of class loading?

Answer:

Loading: Bytecode read by a class loader.
Linking:
- Verification (ensures bytecode validity).
- Preparation (allocates memory for static fields).
- Resolution (replace symbolic references with direct).
Initialization: Executes static initializers and assigns values.

Explain the delegation model of class loaders.

Answer:

Parent-first: A class loader delegates the loading request to its parent before trying itself.
Types of loaders:
- Bootstrap loader → loads core Java classes (rt.jar).
- Platform loader → loads JDK libraries.
- Application loader → loads application classes from classpath.
Custom loaders can load from non-standard sources (e.g., network, plugins).

What is a `ContextClassLoader`?

Answer:

Each thread has a ContextClassLoader.
Allows frameworks (like JDBC, JNDI, Servlets) to load user classes without depending on the system loader.

What are GC roots in Java?

Answer:
Objects directly accessible by JVM, considered always alive:

Local variables in stack frames.
Active threads.
Static variables in loaded classes.
JNI references.

Anything reachable from GC roots → not collected. Unreachable → garbage collected.

Difference between strong, weak, soft, and phantom references?

Answer:

Strong (default): Prevent GC as long as reachable.
Weak: GC collects as soon as no strong references exist (used in WeakHashMap).
Soft: Collected only when memory is low → caching.
Phantom: Collected objects queued for cleanup tasks.

What are the types of Garbage Collectors in Java?

Answer:

Serial GC: Single-threaded; good for small heaps.
Parallel GC: Multi-threaded, throughput-focused.
CMS (deprecated): Concurrent low-pause collector.
G1 GC (default since Java 9): Region-based, balances throughput and pause time.
ZGC & Shenandoah: Ultra-low pause collectors (good for large heaps).

What are safepoints in JVM?

Answer:

A safepoint is a point where all threads stop so JVM can do global operations (GC, deoptimization).
JVM periodically checks for safepoints.
⚠️ Too many safepoints can increase latency.

What is a stop-the-world (STW) pause?

Answer:

During some GC phases, JVM pauses all application threads.
Impact: Long STW pauses affect latency-sensitive apps.
Low-latency GCs (ZGC, Shenandoah) minimize STW pauses.

What is escape analysis?

Answer:

JIT optimization analyzing if an object escapes its method/thread.
If not:
- Allocate object on stack (faster).
- Or replace with scalar variables.
Improves performance by reducing heap allocations.

Common causes of `OutOfMemoryError` (OOM)?

Answer:

Java heap space: Too many objects.
GC overhead limit exceeded: Too much time in GC.
Metaspace OOM: Too many loaded classes.
Unable to create new native thread: OS thread limit reached.
Direct buffer memory OOM: Off-heap NIO buffers not freed.

Difference between throughput and latency-oriented collectors?

Answer:

Throughput collectors: Maximize work done (e.g., Parallel GC).
Latency collectors: Minimize pause time (e.g., CMS, G1, ZGC).
Choice depends on workload:
- Batch jobs → throughput.
- Interactive apps → low latency.

How does G1 GC work?

Answer:

Heap split into regions (1–32 MB).
Collects selected regions instead of whole heap.
Predictable pause times by meeting pause target.
Performs concurrent global marking + evacuation.
⚠️ Default GC for most modern JVMs.

How does ZGC achieve low pauses?

Answer:

Uses colored pointers and load barriers.
Moves objects while threads still run (concurrent compaction).
STW pause is typically < 10ms, even on heaps of 100 GB+.

How do you tune JVM performance?

Answer:

Set heap sizes: -Xms (initial), -Xmx (max).
Enable GC logging: -Xlog:gc*.
Choose GC: -XX:+UseG1GC, -XX:+UseZGC.
Profile app memory allocation patterns before tuning.
⚠️ Don’t guess – always measure with JFR, VisualVM, or profilers.

What is class unloading?

Answer:

JVM can unload classes when their ClassLoader is no longer reachable.
Happens during GC → frees Metaspace memory.
Important for hot-deploy frameworks (Tomcat, OSGi).

What is JIT compilation in JVM?

Answer:

Just-In-Time compiler translates bytecode to native machine code at runtime.
Optimizes hot methods (frequently executed).
Two JITs: C1 (client) → quick compile, C2 (server) → aggressive optimizations.
Tiered compilation: uses both for startup + long-term performance.

How to detect and fix memory leaks in Java?

Answer:

Use tools: VisualVM, JProfiler, Eclipse MAT, JDK Flight Recorder.
Common leaks:
- Static maps holding references.
- Unreleased ThreadLocal values.
- Caches without eviction.
Fix: Use WeakReference, SoftReference, proper resource cleanup.

How does the JVM handle method inlining?

Answer:

JIT replaces small method calls with their body.
Reduces call overhead.
Inlining threshold is tunable (-XX:MaxInlineSize).
⚠️ Too large methods → no inlining.

What is biased locking and lightweight locking? (JDK 8 feature)

Answer:

Biased locking: Optimizes uncontended locks by biasing towards one thread.
Lightweight locking: Uses CAS instead of heavy OS locks.
Both reduce synchronization cost in low-contention scenarios.
Biased locking is removed in JDK 15 for simplicity.

Exceptions & I/O

A key part of Core Java interviews where both freshers and experienced developers are grilled on error handling, resources, and I/O APIs.

What are exceptions in Java?

Answer:

Exception: An event that disrupts program flow.
Java categorizes into:
- Checked exceptions: Must be declared/handled (e.g., IOException, SQLException).
- Unchecked exceptions: Runtime errors (e.g., NullPointerException, ArrayIndexOutOfBoundsException).
- Errors: Serious issues (e.g., OutOfMemoryError, StackOverflowError) that usually can’t be recovered from.

Difference between checked and unchecked exceptions?

Answer:

Checked: Enforced at compile-time; represent recoverable issues. Example: File not found.
Unchecked: Subclasses of RuntimeException; represent programming errors. Example: null dereference.

try {
    new FileReader("abc.txt"); // Checked -> must handle
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

What is the difference between `throw` and `throws`?

Answer:

throw: Used to actually throw an exception.
throws: Declares exceptions in a method signature.

void readFile() throws IOException { 
   throw new IOException("error"); 
}

What is `finally` and when does it not execute?

Answer:

The finally block always runs after try/catch.
Exceptions:
- When JVM exits (System.exit()).
- When a fatal error occurs (OutOfMemoryError).

What is try-with-resources?

Answer:

Introduced in Java 7.
Automatically closes resources that implement AutoCloseable.
Ensures no resource leaks, even on exception.

try (BufferedReader br = Files.newBufferedReader(Path.of("data.txt"))) {
    System.out.println(br.readLine());
}

What are suppressed exceptions?

Answer:

If both a try block and close() throw exceptions, the latter is stored as a suppressed exception.
Access with Throwable.getSuppressed().

try (MyRes r = new MyRes()) {
    throw new RuntimeException("main");
} 
// closing error is suppressed

How do you create a custom exception?

Answer:

Extend Exception (checked) or RuntimeException (unchecked).
Provide constructors for message and cause.

class InvalidInputException extends Exception {
    public InvalidInputException(String msg) { super(msg); }
}

⚠️ Best practice: Keep a small set of meaningful exceptions; don’t overdo custom types.

Why shouldn’t you catch `Exception` or `Throwable` directly?

Answer:

Throwable: Catches even Error (fatal issues you can’t recover from).
Exception: Too broad; hides real issues.
Best practice: Catch specific exceptions you can handle.

What is serialization in Java?

Answer:

Process of converting an object into bytes for storage or transmission.
Achieved with Serializable interface.

⚠️ Pitfalls:

Security risks (deserialization vulnerabilities).
Versioning issues (need serialVersionUID).
Performance overhead.

What is the `transient` keyword?

Answer:

Marks a field not to be serialized.
Useful for sensitive data (passwords) or derived values.

class User implements Serializable {
   private String name;
   private transient String password;
}

Difference between `Serializable` and `Externalizable`?

Answer:

Serializable: Default serialization; simple but inefficient.
Externalizable: Full control via writeExternal and readExternal.
⚠️ Usually avoided unless you need custom, compact formats.

What is the difference between IO (Streams) and NIO?

Answer:

IO (java.io): Stream-based, blocking.
NIO (java.nio): Buffer-based, non-blocking, with channels and selectors.
NIO allows scalable server design with thousands of connections (e.g., Netty).

Difference between byte streams and character streams?

Answer:

Byte streams (InputStream, OutputStream): Handle raw binary data.
Character streams (Reader, Writer): Handle text with encoding.
Always specify charset when converting.

Why use buffered streams/writers?

Answer:

Reduce costly disk/network calls by batching reads/writes.

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    br.lines().forEach(System.out::println);
}

How does Java handle character encoding?

Answer:

Default charset depends on system (platform-dependent).
Always use StandardCharsets.UTF_8 explicitly.

Files.readString(path, StandardCharsets.UTF_8);

What is `Path` vs `File` in Java?

Answer:

File: Legacy API for file paths.
Path (NIO.2, Java 7+): Modern API with better support for symbolic links, watch service, etc.

Path p = Paths.get("data.txt");
Files.exists(p);

What is `FileChannel` and memory-mapped files?

Answer:

FileChannel: Efficient reading/writing using buffers.
map(): Creates a memory-mapped buffer → OS pages file into memory.
Used for high-performance file access (e.g., databases, caches).

What is the WatchService API?

Answer:

Introduced in Java 7 (NIO.2).
Monitors file system changes (create, modify, delete).

WatchService ws = FileSystems.getDefault().newWatchService();
path.register(ws, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);

What are common causes of `IOException`?

Answer:

File not found / no permission.
Disk full.
Network errors.
Always handle with user-friendly messages; don’t just print stack traces.

Best practices for exceptions & I/O in interviews?

Prefer checked exceptions for recoverable errors.
Don’t swallow exceptions silently.
Use try-with-resources.
Always specify charset in I/O.
Avoid Java native serialization for new projects → prefer JSON/Protobuf.

Java 8 and Modern Java

This is a must-know area because most interviews today focus on Java 8 fundamentals (streams, lambdas, functional interfaces, Optional) and test awareness of modern features.

What are lambdas in Java?

Answer:

Introduced in Java 8 for functional programming.
A lambda expression is a concise way to represent an anonymous function.

List<Integer> nums = Arrays.asList(1,2,3);
nums.forEach(n -> System.out.println(n));

Syntax: (parameters) -> expression or (parameters) -> { statements }.
Enables passing behavior (functions) as arguments.
Backed by invokedynamic bytecode for efficiency.

What are functional interfaces?

Answer:

Interfaces with a single abstract method (SAM).
Annotated with @FunctionalInterface.
Examples: Runnable, Callable, Comparator, Function, Predicate.
Used with lambdas and method references.

@FunctionalInterface
interface Calculator {
    int add(int a, int b);
}
Calculator c = (a, b) -> a + b;

Method references in Java 8?

Answer:

Shorthand for lambdas that just call an existing method.

Types:

object::instanceMethod → "abc"::toUpperCase
Class::staticMethod → Math::max
Class::new → ArrayList::new

list.forEach(System.out::println);

Explain Streams API.

Answer:

A stream is a pipeline of data operations (map, filter, reduce).
Operations are either intermediate (return stream) or terminal (produce result).
Streams are lazy; operations are evaluated only when terminal operation runs.

int sum = nums.stream()
   .filter(n -> n % 2 == 0)
   .mapToInt(Integer::intValue)
   .sum();

⚠️ Interview Tip: Streams don’t store data → they operate on collections or I/O sources.

Difference between `map` and `flatMap`?

Answer:

map: Transforms each element into another.
flatMap: Transforms and flattens nested streams.

Stream<List<String>> s = Stream.of(List.of("A","B"), List.of("C"));
s.flatMap(List::stream).forEach(System.out::println); // A B C

What is the difference between sequential and parallel streams?

Answer:

Sequential: Processes elements in a single thread.
Parallel: Splits data into chunks and processes across multiple threads (using ForkJoinPool).
⚠️ Use parallel streams carefully → may cause contention for small datasets or blocking operations.

What is `Optional` and why use it?

Answer:

Container object for possibly-absent values.
Avoids NullPointerException.
Provides expressive APIs: ifPresent, orElse, orElseGet, map, flatMap.

Optional<String> name = Optional.ofNullable(getName());
name.ifPresent(System.out::println);

⚠️ Don’t overuse → avoid Optional for fields/parameters; best for return types.

What are default and static methods in interfaces?

Answer:

Default methods (Java 8): Provide method body in interfaces.
Static methods (Java 8): Utility methods in interfaces.

interface Shape {
   default void draw() { System.out.println("Drawing"); }
   static void info() { System.out.println("Shape info"); }
}

Introduced to enable interface evolution without breaking existing code.

What is the `java.time` API (Java 8)?

Answer:

Modern date-time API inspired by Joda-Time.
Immutable and thread-safe.
Classes: LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Instant, Duration, Period.

LocalDate today = LocalDate.now();
LocalDate nextWeek = today.plusWeeks(1);

Difference between `forEach` and `forEachOrdered`?

Answer:

forEach: May process in any order (especially in parallel streams).
forEachOrdered: Preserves encounter order.

What are records in Java (Java 16)?

Answer:

A record is a concise class for immutable data carriers.
Automatically generates equals, hashCode, toString.

record Point(int x, int y) {}
Point p = new Point(1,2);

What are sealed classes (Java 17)?

Answer:

Restrict which classes can extend/implement.
Enforced by compiler & JVM → improves pattern matching exhaustiveness.

sealed interface Shape permits Circle, Square {}

Pattern matching for `instanceof` (Java 16)?

Answer:

No need to cast after instanceof.

if (obj instanceof String s) {
   System.out.println(s.toUpperCase());
}

Switch expressions (Java 14+)?

Answer:

Switch is now an expression, not just a statement.

String dayType = switch(day) {
   case MONDAY, FRIDAY -> "Work";
   case SATURDAY, SUNDAY -> "Off";
   default -> "Unknown";
};

Text blocks (Java 15)?

Answer:

Multi-line string literals with """.

String json = """
{
  "lang": "Java",
  "year": 1995
}
""";

What are virtual threads (Java 21)?

Answer:

Part of Project Loom.
Thousands of lightweight threads scheduled by JVM.
Enable scalable concurrency with blocking-style code.
Replace callback-based async with structured concurrency.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> System.out.println("Hello Loom!"));
}

How does `var` work in Java 10?

Answer:

Local variable type inference.
Still statically typed; type determined at compile time.

var list = new ArrayList<String>(); // type = ArrayList<String>

⚠️ Avoid overuse → reduces readability.

Difference between `Collectors.toList()` and `Collectors.toUnmodifiableList()` (Java 10)?

Answer:

toList(): Returns mutable list (but unspecified implementation).
toUnmodifiableList(): Returns immutable list → modification throws UnsupportedOperationException.

How do you use `CompletableFuture` with Streams (Java 8+)?

Answer:

Combine async tasks and collect results.

List<CompletableFuture<Integer>> futures = nums.stream()
   .map(n -> CompletableFuture.supplyAsync(() -> n * n))
   .toList();
List<Integer> results = futures.stream().map(CompletableFuture::join).toList();

Best practices for Java 8+ and modern features?

Prefer streams for readability but avoid over-chaining.
Use parallel streams only after profiling.
Use Optional only for return types.
Use records for DTOs.
Adopt sealed classes + pattern matching for domain models.
Embrace Project Loom virtual threads for new concurrent systems.

Scenario-Based Core Java Interview Questions

These are practical, problem-solving questions that interviewers love to ask mid-senior Java developers (5-10+ years) to check real-world coding ability, design sense, and debugging skills.

How would you design an immutable class in Java?

Answer:
Steps:

Declare the class final.
Make all fields private and final.
No setters.
Initialize fields via constructor.
Perform deep copies of mutable objects in constructor and getters.

public final class Employee {
   private final String name;
   private final Date dob;
   public Employee(String name, Date dob) {
      this.name = name;
      this.dob = new Date(dob.getTime()); // defensive copy
   }
   public String getName() { return name; }
   public Date getDob() { return new Date(dob.getTime()); }
}

How would you implement a thread-safe counter?

Answer:
Options:

Use synchronized increment method.
Use AtomicInteger.
For high contention, use LongAdder.

AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();

How to prevent `HashMap` key corruption in multithreaded code?

Answer:

HashMap is not thread-safe; concurrent access leads to data races.
Use ConcurrentHashMap for multi-threading.
Or wrap Collections.synchronizedMap(new HashMap<>()).

How would you design an LRU Cache in Java?

Answer:

Use LinkedHashMap with accessOrder set to true.
Override removeEldestEntry.

class LRUCache<K,V> extends LinkedHashMap<K,V> {
   private final int capacity;
   LRUCache(int capacity) {
      super(capacity, 0.75f, true);
      this.capacity = capacity;
   }
   protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
      return size() > capacity;
   }
}

How do you debug a `ConcurrentModificationException`?

Answer:

Happens when a collection is modified while iterating.
Solutions:
- Use Iterator.remove() instead of list.remove().
- Use CopyOnWriteArrayList or ConcurrentHashMap.

How do you design a producer-consumer system in Java?

Answer:

Use BlockingQueue.
Producer puts items, consumer takes items.

BlockingQueue<Integer> q = new ArrayBlockingQueue<>(10);
new Thread(() -> { try { q.put(1); } catch(Exception e){} }).start();
new Thread(() -> { try { System.out.println(q.take()); } catch(Exception e){} }).start();

How do you avoid deadlocks in Java?

Answer:

Consistent lock ordering.
Use tryLock() with timeout.
Minimize nested locks.
Consider lock-free algorithms (e.g., CAS, concurrent collections).

How would you handle a memory leak in a web application?

Answer:

Use profiling tools (VisualVM, JFR, MAT).
Look for:
- Static collections growing indefinitely.
- Unreleased ThreadLocal.
- Cache without eviction.
Fix: Remove references, weak references, explicit remove() in ThreadLocals.

How to implement a singleton in Java?

Answer:

Best way: Enum singleton (thread-safe, serialization-safe).

public enum Singleton {
   INSTANCE;
   public void doSomething() {}
}

Alternative: Bill Pugh’s static inner class approach.

How would you design a retry mechanism for failed operations?

Answer:

Use a loop with backoff.
Java 9+ has CompletableFuture.handle for retrying.
Frameworks: Resilience4j, Spring Retry.

int retries = 3;
while (retries-- > 0) {
   try { callService(); break; }
   catch(Exception e) { Thread.sleep(1000); }
}

How to handle large file processing in Java?

Answer:

Use BufferedReader or Files.lines() (Java 8 streams).
For very large files → memory-mapped I/O (FileChannel.map).
Always process line-by-line to avoid OOM.

How to prevent `OutOfMemoryError` in a cache system?

Answer:

Use WeakHashMap for GC-friendly keys.
Add eviction policies (LRU, TTL).
Use frameworks like Caffeine/Guava.

How to make a class thread-safe without using synchronization?

Answer:

Use immutable objects.
Use atomic classes (AtomicInteger, ConcurrentHashMap).
Use functional programming (no shared state).

How do you implement a read-write lock?

Answer:

Use ReentrantReadWriteLock.
Multiple readers allowed, only one writer.

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock();
try { /* read */ } finally { lock.readLock().unlock(); }

How do you debug high CPU usage in a Java app?

Answer:

Capture thread dump (jstack <pid>).
Identify hot threads stuck in loops/locks.
Use profiler (JFR, YourKit, VisualVM).
Fix: Optimize loops, reduce contention, tune GC.

How do you ensure database connections are always closed?

Answer:

Use try-with-resources.
Ensure Connection, Statement, ResultSet implement AutoCloseable.

try(Connection con = ds.getConnection();
    Statement st = con.createStatement();
    ResultSet rs = st.executeQuery("select * from users")) {
   while(rs.next()) System.out.println(rs.getString(1));
}

How would you design a rate limiter in Java?

Answer:

Use a token bucket algorithm.
Libraries: Guava RateLimiter, Resilience4j.

RateLimiter limiter = RateLimiter.create(5); // 5 permits/sec
limiter.acquire();

How do you safely share a collection across threads?

Answer:

Use concurrent collections (ConcurrentHashMap, CopyOnWriteArrayList).
Wrap with Collections.synchronizedList.
Immutable collections when possible.

How do you implement delayed tasks in Java?

Answer:

Use ScheduledExecutorService.
Or DelayQueue for precise scheduling.

ScheduledExecutorService ses = Executors.newScheduledThreadPool(1);
ses.schedule(() -> System.out.println("Hello"), 1, TimeUnit.SECONDS);

How do you debug a `StackOverflowError`?

Answer:

Happens due to deep recursion or infinite cycles.
Use thread dump to locate recursive method.
Fix: Convert recursion to iteration or add termination conditions.

Related Java Interview Guides

Frequently Asked Questions (FAQ)

Which Java version should I prepare for interviews?

Most companies test Java 8 deeply (streams, lambdas, Optional, date/time API). However, being aware of modern features (Java 11, 17, 21) – such as var, records, sealed classes, and virtual threads – gives you an edge in senior-level interviews.

How many Core Java interview questions should I prepare?

Quality > Quantity.

For freshers: ~100 well-practiced questions (OOP, Strings, Collections).
For experienced (3–5 years): Add ~50 on concurrency, streams, generics.
For senior (10+ years): Focus on JVM, GC tuning, performance.

How do I explain my Java project in an interview?

Use the STAR method (Situation, Task, Action, Result):

Situation: Context of the project.
Task: Your responsibility.
Action: What you did (e.g., implemented caching with ConcurrentHashMap).
Result: Outcome (e.g., improved response time by 40%).

What is the difference between Core Java and Advanced Java?

Core Java: Covers basic building blocks – OOP, Collections, Multithreading, Exception handling, JVM internals.
Advanced Java: Includes frameworks and technologies like JDBC, Servlets, JSP, Hibernate, Spring, and distributed systems.

What are the most asked Core Java interview topics?

OOP principles and basics (equals, hashCode, final, static).
Collections & Generics (HashMap, ArrayList, fail-fast iterators).
Concurrency (volatile, synchronized, executors, deadlocks).
JVM memory management and Garbage Collection.
Java 8 features (streams, lambdas, Optional).
Exception handling & best practices.

Is Java still in demand in 2025?

Yes. Java remains a top backend language for enterprise apps, microservices (Spring Boot), fintech, and Android. Many product-based companies (Amazon, Google, Microsoft, banks) still conduct Java-heavy interviews.

How do I avoid `NullPointerException` in Java interviews?

Use Objects.requireNonNull.
Use Optional for return types.
Defensive checks before dereferencing.
Initialize collections instead of leaving them null.

How do I prepare Core Java for interviews in 1 month?

Week 1: OOP, Strings, Collections basics.
Week 2: Exceptions, Generics, Java 8 features.
Week 3: Concurrency, Multithreading, JVM basics.
Week 4: Scenario-based coding questions & mock interviews.

Is Core Java enough to crack interviews?

For freshers: Core Java is usually enough.
For experienced devs: You need Core Java + Spring/Spring Boot, SQL, system design, and problem-solving skills.

Final Words

Java has evolved, but its core principles remain timeless. If you master the concepts in this core java interview questions guide, you’ll be well-prepared not just for interviews but also for real-world enterprise projects.

Keep practicing, keep building, and remember: “The best Java developers are not the ones who know everything – but the ones who can learn and apply concepts fast.”

Quick Answers

Java Basics & OOP (Freshers)

What are the OOP principles in Java?

What is the difference between a class and an object?

Explain access modifiers in Java.

Abstract class vs Interface?

Can Java support multiple inheritance?

What is the difference between static and instance members?

What is immutability and why is it important?

What are primitive types vs wrapper classes?

What is autoboxing and unboxing?

What is a package in Java?

What is the difference between == and equals()?

Explain method overloading vs overriding.

What is the difference between final, finally, and finalize()?

What is the difference between JDK, JRE, and JVM?

What is a constructor in Java?

What is the default constructor?

Can constructors be inherited?

Order of initialization in Java?

What is shadowing in Java?

Difference between this and super?

Strings & Core Java Basics

Why is String immutable in Java?

StringBuilder vs StringBuffer vs String concatenation

== vs equals() for strings

What is the String Pool and how does intern() work?

How does substring() work? Has its memory behavior changed?

Best way to build large strings efficiently?

How do you compare strings ignoring case safely (i18n pitfalls)?

Unicode, UTF-16, code points, and why char can be misleading

Encoding & decoding bytes and strings

Explain String.format, Formatter, and MessageFormat

What is CharSequence and why should you care?

Regular expressions with String vs Pattern/Matcher

How do text blocks work and when should you use them? (Java 15+)

String.join vs StringJoiner vs Collectors.joining

Trimming, blank checks, and whitespace handling (Java 11+)

String search APIs (indexOf, contains, regionMatches)

Can you switch on strings? (Since Java 7)

String.valueOf vs toString and null-safety

Repeating and indenting strings (Java 11+)

When should you use intern()? Any risks?

Common performance pitfalls with strings

Idiomatic snippets you should know (quick wins)

Collections & Generics (3 Years Experience)

Explain the Java Collections hierarchy.

Difference between ArrayList and LinkedList?

How does HashMap work internally?

Why must equals() and hashCode() be consistent?

HashMap vs Hashtable vs ConcurrentHashMap?

Difference between HashSet, LinkedHashSet, and TreeSet?

Fail-fast vs Fail-safe iterators

Difference between Comparable and Comparator?

Generics in Java – why and how?

What is the PECS principle in generics?

Why can’t you create new T[] in generics?

Raw types in generics – why avoid them?

What is ConcurrentModificationException?

What is CopyOnWriteArrayList? When to use?

Difference between Vector and ArrayList?

What is the difference between capacity and size?

WeakHashMap vs HashMap?

EnumSet and EnumMap

What is the difference between HashMap and IdentityHashMap?

What are bounded type parameters in generics?

Concurrency & Multithreading (5 Years Experience)

What is a thread in Java?

Difference between process and thread?

What does volatile guarantee?

How does synchronized work?

Deadlock: What is it and how to avoid it?

Difference between Runnable, Callable, and Future?

What is CompletableFuture and why is it better?

Difference between thread pool types in Executors?

What is the Java Memory Model (JMM)?

What is ThreadLocal and when to use it?

Difference between notify and notifyAll?

Spurious wakeups in wait() – why loop conditions?

Difference between ReentrantLock and synchronized?

What is the difference between `static` and instance members?

What is the difference between `==` and `equals()`?

What is the difference between `final`, `finally`, and `finalize()`?

Difference between `this` and `super`?

Why is `String` immutable in Java?

`StringBuilder` vs `StringBuffer` vs `String` concatenation

`==` vs `equals()` for strings

What is the String Pool and how does `intern()` work?

How does `substring()` work? Has its memory behavior changed?

Unicode, UTF-16, code points, and why `char` can be misleading

Explain `String.format`, `Formatter`, and `MessageFormat`

What is `CharSequence` and why should you care?

Regular expressions with `String` vs `Pattern`/`Matcher`

`String.join` vs `StringJoiner` vs `Collectors.joining`

String search APIs (`indexOf`, `contains`, `regionMatches`)

Can you `switch` on strings? (Since Java 7)

`String.valueOf` vs `toString` and null-safety

When should you use `intern()`? Any risks?

Difference between `ArrayList` and `LinkedList`?

How does `HashMap` work internally?

Why must `equals()` and `hashCode()` be consistent?

`HashMap` vs `Hashtable` vs `ConcurrentHashMap`?

Difference between `HashSet`, `LinkedHashSet`, and `TreeSet`?

Difference between `Comparable` and `Comparator`?

Why can’t you create `new T[]` in generics?

What is `ConcurrentModificationException`?

What is `CopyOnWriteArrayList`? When to use?

Difference between `Vector` and `ArrayList`?

`WeakHashMap` vs `HashMap`?

`EnumSet` and `EnumMap`

What is the difference between `HashMap` and `IdentityHashMap`?

Difference between `process` and `thread`?

What does `volatile` guarantee?

How does `synchronized` work?

Difference between `Runnable`, `Callable`, and `Future`?

What is `CompletableFuture` and why is it better?

What is `ThreadLocal` and when to use it?

Difference between `notify` and `notifyAll`?

Spurious wakeups in `wait()` – why loop conditions?

Difference between `ReentrantLock` and `synchronized`?

Difference between `ForkJoinPool` and `ThreadPoolExecutor`?

What is `CountDownLatch` vs `CyclicBarrier`?

Difference between `Semaphore` and `Exchanger`?

What is a `ContextClassLoader`?

Common causes of `OutOfMemoryError` (OOM)?

What is the difference between `throw` and `throws`?

What is `finally` and when does it not execute?

Why shouldn’t you catch `Exception` or `Throwable` directly?

What is the `transient` keyword?

Difference between `Serializable` and `Externalizable`?

What is `Path` vs `File` in Java?

What is `FileChannel` and memory-mapped files?

What are common causes of `IOException`?

Difference between `map` and `flatMap`?

What is `Optional` and why use it?

What is the `java.time` API (Java 8)?

Difference between `forEach` and `forEachOrdered`?

Pattern matching for `instanceof` (Java 16)?

How does `var` work in Java 10?

Difference between `Collectors.toList()` and `Collectors.toUnmodifiableList()` (Java 10)?

How do you use `CompletableFuture` with Streams (Java 8+)?