Java for Interviews

Master the foundational building blocks of Java — data types, operators, control flow, and variable scope that every interview tests.

• Variable declarations: valid naming conventions and initialization syntax

• Data types: primitive types (int, double, char, boolean, byte, short, long, float)

• Reference types vs primitive types: memory storage differences

• Type casting: implicit vs explicit, widening vs narrowing

• Operators: arithmetic, relational, logical, bitwise, assignment, ternary

• Control flow: if-else, switch-case, break, continue statements

• Loops: for, while, do-while, and enhanced for loop

• Scope: local variables, instance variables, static variables

• Default values: primitives vs reference types initialization

• Keywords and identifiers: reserved words and naming rules

Understand method declaration, overloading, overriding, and static vs instance behavior — core topics in every Java interview.

• Method declaration: return type, name, parameters, and access modifiers

• Method signature: name + parameter list (used for overloading)

• Method overloading: same name, different parameters (compile-time polymorphism)

• Method overriding: redefining inherited methods (runtime polymorphism)

• Static methods: class-level methods, cannot access instance variables directly

• Instance methods: object-level methods, can access both static and instance members

• Main method: public static void main(String[] args) as program entry point

• Varargs: variable number of arguments using ellipsis (...)

• Return statements: returning values vs void methods

• Method invocation: calling methods and passing arguments

String immutability, the string pool, equals() vs ==, and StringBuilder are among the most frequently tested Java interview concepts.

• String immutability: why strings cannot be modified once created

• String creation: literal vs new keyword and string pool behavior

• String comparison: equals() vs == operator (content vs reference)

• String methods: length(), charAt(), substring(), indexOf(), contains()

• String concatenation: + operator vs concat() method

• StringBuilder and StringBuffer: mutable alternatives to String

• Performance: StringBuilder (not synchronized) vs StringBuffer (thread-safe)

• intern() method: adding string to pool for memory optimization

• isEmpty() vs isBlank(): checking empty string vs whitespace-only (Java 11)

• String formatting: format() and printf() methods

Learn array declaration, initialization, traversal, and the Arrays utility class — tested in almost every Java assessment.

• Array declaration: type[] name or type name[] syntax

• Array initialization: with size, with values, and multidimensional arrays

• Array access: index-based access and ArrayIndexOutOfBoundsException

• Array length: length property (not a method)

• Default values: 0 for numeric, false for boolean, null for objects

• Enhanced for loop: iterating arrays without an index

• Arrays class: sort(), binarySearch(), copyOf(), fill(), equals()

• Multidimensional arrays: 2D arrays and jagged arrays

• Array copying: System.arraycopy(), Arrays.copyOf(), and clone()

• Array limitations: fixed size and single type storage

Master checked vs unchecked exceptions, try-catch-finally, and custom exceptions — critical concepts interviewers probe in depth.

• Exception hierarchy: Throwable -> Error and Exception

• Checked exceptions: must be caught or declared (IOException, SQLException)

• Unchecked exceptions: runtime exceptions (NullPointerException, ArithmeticException)

• try-catch blocks: handling exceptions with multiple catch blocks

• finally block: cleanup code that always executes

• throw keyword: throwing an exception explicitly

• throws keyword: declaring exceptions in a method signature

• Custom exceptions: extending Exception or RuntimeException

• try-with-resources (Java 7): automatic resource management

• Exception propagation: how exceptions travel up the call stack

Understand List, Set, Map, and their implementations — the most heavily tested topic in Java interviews at all levels.

• Collection interface: root interface (List, Set, Queue extend it)

• List interface: ordered collection that allows duplicates (ArrayList, LinkedList)

• Set interface: no duplicates allowed (HashSet, TreeSet, LinkedHashSet)

• Map interface: key-value pairs, not part of Collection (HashMap, TreeMap, LinkedHashMap)

• ArrayList vs LinkedList: random access vs insertion/deletion performance

• HashSet vs TreeSet: unordered O(1) vs sorted O(log n)

• HashMap vs TreeMap vs LinkedHashMap: unordered vs sorted vs insertion-order

• Iterator: hasNext(), next(), remove() methods

• Fail-fast iterators: ConcurrentModificationException when modified during iteration

• Queue interface: FIFO operations — poll(), peek(), offer()

Grasp type parameters, wildcards, bounded types, and type erasure — a topic that separates intermediate from advanced Java candidates.

• Type safety: compile-time type checking that eliminates ClassCastException

• Generic class: class definition with type parameters <T>

• Generic method: method with its own type parameter <T>

• Type parameters: T (type), E (element), K (key), V (value), N (number)

• Bounded type parameters: <T extends Number> restricting to specific types

• Wildcards: ? represents an unknown type

• Upper bounded wildcard: <? extends Number> accepts Number or subclasses

• Lower bounded wildcard: <? super Integer> accepts Integer or superclasses

• Type erasure: how Java implements generics for backward compatibility

• Generic restrictions: cannot instantiate T or create a generic array

Write concise functional-style code using lambdas, functional interfaces, and method references — essential for modern Java interviews.

• Lambda syntax: (parameters) -> expression or (parameters) -> { statements; }

• Functional interfaces: interfaces with a single abstract method (@FunctionalInterface)

• Built-in functional interfaces: Predicate, Function, Consumer, Supplier

• Lambda vs anonymous class: concise syntax for implementing functional interfaces

• Type inference: compiler infers parameter types in lambdas

• Variable capture: accessing effectively final variables from enclosing scope

• Method references: shorthand for lambdas (Class::method, object::method)

• Constructor references: Class::new for creating objects

• Lambda use cases: collection operations, event handling, threading

• Benefits: concise code, functional programming style, improved readability

Process collections functionally using filter, map, reduce, and collect — stream pipelines are a staple of senior Java interview questions.

• Stream creation: from collections, arrays, or using Stream.of()

• Intermediate operations: filter(), map(), sorted(), distinct(), limit()

• Terminal operations: collect(), forEach(), reduce(), count(), anyMatch()

• Lazy evaluation: intermediate operations not executed until terminal operation

• Stream pipeline: chain of operations transforming data

• Collectors: toList(), toSet(), toMap(), joining(), groupingBy()

• Parallel streams: parallelStream() for concurrent processing

• Stream vs Collection: one-time use, lazy evaluation, functional operations

• map() vs flatMap(): one-to-one transformation vs flattening nested structures

• Common patterns: filtering, mapping, reducing, and grouping data

Build thread-safe programs using synchronization, locks, and the executor framework — concurrency knowledge is required for mid-to-senior Java roles.

• Thread creation: extending Thread class or implementing Runnable interface

• Thread lifecycle: new, runnable, running, waiting, and terminated states

• start() vs run(): start() creates new thread, run() executes in current thread

• Thread.sleep(): pauses current thread for specified milliseconds

• Synchronization: preventing race conditions using the synchronized keyword

• Deadlock: two threads waiting for each other's locks indefinitely

• Executor framework: thread pools, ExecutorService, Executors factory methods

• Callable vs Runnable: Callable returns a value and can throw checked exceptions

• volatile keyword: ensures visibility of variable changes across threads

• ReentrantLock: explicit lock with more flexibility than synchronized