Java Interview Questions

Java is a statically-typed, object-oriented language running on the JVM. Write once, run anywhere via bytecode and JIT compilation.

JVM executes bytecode; JRE provides JVM + libraries to run apps; JDK adds compiler and tools to develop apps.

Primitives (int, boolean) are value types; wrappers (Integer, Boolean) are objects. Autoboxing converts between them automatically.

Integer x = 5; // autobox
int y = x;      // unbox

Core interfaces: List, Set, Map. Implementations: ArrayList, LinkedList, HashSet, TreeSet, HashMap, TreeMap. Choose based on ordering, uniqueness, and performance.

List: ordered, allows duplicates. Set: unique elements, no index. Map: key-value pairs. Use HashMap for average O(1) lookup; TreeMap for sorted keys.

Generics enable type-safe collections and APIs. Use wildcards (<?>, <? extends T>, <? super T>) to model variance.

List<String> names = new ArrayList<>();
List<? extends Number> nums; // read-only covariant

Checked must be declared/handled (IOException); unchecked are runtime errors (NullPointerException). Prefer meaningful exception types and handle at boundaries.

Use threads, executors, and futures for parallelism. Synchronize shared state with synchronized blocks/locks; prefer high-level concurrency utilities.

ExecutorService pool = Executors.newFixedThreadPool(4);
Future<Integer> f = pool.submit(() -> 42);
Integer v = f.get();

Declarative operations on collections: map, filter, reduce. Streams can be parallel; emphasize immutability and side-effect-free lambdas.

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

GC reclaims unused objects automatically. Algorithms vary (G1, ZGC). Avoid memory leaks by releasing references and using weak references where appropriate.

Defines visibility and ordering of reads/writes across threads. Use volatile, locks, and happens-before relations to ensure correctness.

Equal objects must have equal hashCodes; breaking the contract leads to incorrect behavior in hashed collections.

Immutable objects are thread-safe and simpler to reason about. Use final fields and defensive copies.

Use Collectors for grouping, partitioning, and summarizing stream results.

Maven uses XML and conventions; Gradle is Groovy/Kotlin-based and more flexible. Both manage dependencies and builds.