Java Interview Questions for Freshers 2026 — Top 50 with Answers

JVM (Java Virtual Machine) executes bytecode. JRE (Java Runtime Environment) = JVM + standard libraries for running Java apps. JDK (Java Development Kit) = JRE + compiler + development tools for building Java apps.

== compares object references (memory addresses). .equals() compares actual content/values of objects. For Strings, always use .equals() to compare values.

Autoboxing is automatic conversion of primitive to wrapper class (int → Integer). Unboxing is the reverse (Integer → int). Example: Integer x = 5; (autoboxing), int y = x; (unboxing).

final variable = value cannot be changed. final method = cannot be overridden. final class = cannot be extended/inherited. Example: final int MAX = 100;

String is immutable. StringBuilder is mutable and not thread-safe (faster). StringBuffer is mutable and thread-safe (synchronized, slower). Use StringBuilder for single-threaded string manipulation.

static members belong to the class, not instances. static variables are shared across all objects. static methods can be called without creating objects. static blocks run when class is loaded.

Widening (implicit): smaller type to larger (int → long). Narrowing (explicit): larger type to smaller (double → int), requires cast: int x = (int) 3.14;

Encapsulation (wrapping data + methods), Inheritance (child extends parent), Polymorphism (same method behaves differently), Abstraction (hiding complexity). These are the foundation of Java architecture.

Abstract class can have constructors, instance variables, and both abstract + concrete methods. Interface (before Java 8) has only abstract methods. After Java 8, interfaces can have default and static methods. A class can implement multiple interfaces but extend only one abstract class.

Overloading: same method name, different parameters, in the same class (compile-time polymorphism). Overriding: same method signature in child class (runtime polymorphism). Overriding requires @Override annotation.

Encapsulation bundles data (variables) and methods into a single unit (class) and restricts direct access using access modifiers. Example: private variables with public getters/setters.

super refers to the parent class. super() calls parent constructor. super.method() calls parent method. super.variable accesses parent variable. super() must be the first statement in child constructor.

this refers to the current object. Used to disambiguate instance variables from parameters: this.name = name. Also used to call other constructors: this(param).

ArrayList uses dynamic array — O(1) random access, O(n) insert/delete. LinkedList uses doubly-linked list — O(n) random access, O(1) insert/delete at known position. Use ArrayList for most cases.

HashMap: not synchronized, allows one null key, faster. Hashtable: synchronized (thread-safe), no null keys. HashMap is preferred; use ConcurrentHashMap for thread-safety.

List: ordered, allows duplicates, accessed by index (ArrayList, LinkedList). Set: unordered, no duplicates (HashSet, TreeSet). Use Set when you need unique elements.

HashMap uses an array of buckets. Each key's hashCode() determines the bucket index. Collisions are handled by linked list (Java 7) or balanced tree (Java 8+ when > 8 entries). Load factor 0.75 triggers resize.

Comparable: natural ordering, class implements compareTo(). Comparator: custom ordering, separate class implements compare(). Use Comparable for default sorting, Comparator for multiple sort criteria.

Checked exceptions must be caught or declared (IOException, SQLException). Unchecked exceptions extend RuntimeException and don't require handling (NullPointerException, ArrayIndexOutOfBoundsException). Errors (OutOfMemoryError) are not exceptions.

Introduced in Java 7, automatically closes resources implementing AutoCloseable. Syntax: try (InputStream is = new FileInputStream("file.txt")) { ... }. No need for finally block to close resources.

Yes, try can be used with just finally (try-finally) or with try-with-resources. But you cannot have both try without catch and without finally — at least one is required.

throw is used to explicitly throw an exception: throw new Exception("error"). throws is used in method signature to declare exceptions: public void readFile() throws IOException.

Thread is a class (single inheritance limitation). Runnable is an interface (can implement multiple). Best practice: implement Runnable and pass to Thread constructor. Java 8+: use lambda with Runnable.

Synchronization prevents multiple threads from accessing shared resources simultaneously. Use synchronized keyword on methods or blocks. Every object has an intrinsic lock (monitor).

volatile ensures a variable is read from main memory, not thread cache. Provides visibility guarantee but NOT atomicity. Use for simple flags shared between threads.

Deadlock occurs when two threads each hold a lock the other needs. Prevention: lock ordering (always acquire locks in the same order), use tryLock() with timeout, avoid nested locks.

Lambdas are anonymous functions. Syntax: (params) -> expression or (params) -> { statements }. Example: list.forEach(item -> System.out.println(item)). Requires a functional interface (single abstract method).

Streams provide a functional approach to processing collections. Operations: filter(), map(), reduce(), collect(), forEach(). Streams are lazy (operations execute only when terminal operation is called). Example: list.stream().filter(x -> x > 5).collect(Collectors.toList()).

Optional is a container that may or may not contain a value. Prevents NullPointerException. Methods: isPresent(), get(), orElse(), orElseThrow(), map(), flatMap(). Example: Optional.ofNullable(value).orElse("default").

An interface with exactly one abstract method. Annotated with @FunctionalInterface. Common ones: Predicate<T> (boolean test), Function<T,R> (T→R), Consumer<T> (void accept), Supplier<T> (T get).