Comprehensive Java Interview Questions and Topics

Java interview topics have evolved; earlier focus on String vs StringBuilder, Vector vs Array, HashMap vs Hashtable, now include advanced areas such as NIO, design patterns, unit testing, distributed systems, microservices, concurrency, algorithms, and data structures.

Topics Covered

Multithreading, concurrency and thread basics

Basic principles of data type conversion

Garbage Collection (GC)

Java Collections Framework

Arrays, Strings

GOF Design Patterns, SOLID

Abstract classes and interfaces

Core Java concepts such as equals and hashCode

Generics and enums

Java IO and NIO

Common network protocols

Data structures and algorithms in Java

Regular expressions

JVM internals

Best practices

JDBC

Date, Time and Calendar

XML processing

JUnit testing

General programming questions

Sample Questions

Examples include: Can a volatile array be created in Java? Does volatile make a non‑atomic operation atomic? How to use wait() correctly? What guarantees does volatile provide? Differences between 10‑thread and 2‑thread synchronized code? How to write a producer‑consumer solution with wait‑notify?

Additional sections address experienced‑level topics such as busy spin, thread dumps, Swing thread safety, thread‑local variables, singleton implementation, differences between sleep and wait, immutable objects, and whether mutable objects can be part of immutable ones.

Data‑type questions cover price representation, byte‑to‑String conversion, long casting, forced casting effects, class hierarchy casting, clone method location, thread‑safety of ++, and memory usage of int vs Integer.

JVM and GC questions explore 64‑bit JVM int size, Serial vs Parallel GC, WeakReference vs SoftReference, WeakHashMap behavior, UseCompressedOops flag, determining JVM bitness, maximum heap sizes, and differences among JRE, JDK, JVM, and JIT.

Collections questions compare List, Set, Map, Queue; poll vs remove; LinkedHashMap vs PriorityQueue; ArrayList vs LinkedList; sorting methods; printing arrays; LinkedList structure; TreeMap implementation; Hashtable vs HashMap; HashSet internals; safe removal during iteration; default sizes; hashCode collisions; Comparator vs Comparable.

IO/NIO questions discuss socket‑thread ratios, ByteBuffer creation and usage, endianness, direct vs non‑direct buffers, memory‑mapped buffers, TCP_NO_DELAY, TCP vs UDP, and differences between ByteBuffer and StringBuffer.

Best‑practice sections list guidelines for multithreaded programming, Collections usage, thread handling, IO, JDBC, and method overloading.

Date/Time questions cover SimpleDateFormat thread safety, formatting, time zones, java.util.Date vs java.sql.Date, date difference calculation, and parsing strings to dates.

JUnit questions address testing static methods, exception testing, test libraries, and @Before vs @BeforeClass.

Programming questions include numeric string validation, generic LRU cache, byte‑to‑long conversion, string reversal without StringBuffer, word frequency counting, palindrome detection, string permutations, duplicate array elements, string‑to‑int conversion, and swapping integers without a temporary variable.

OOP and design‑pattern questions explore interfaces, abstract classes, singleton, Liskov substitution, Law of Demeter, adapter, dependency injection, constructor vs setter injection, visitor, composite, inheritance vs composition, overloading vs overriding, nested static vs top‑level classes, aggregation vs composition, open‑closed principle, abstract factory vs prototype, and more.

Additional miscellaneous questions address static vs top‑level classes, regex for numeric strings, checked vs unchecked exceptions, throw vs throws, Serializable vs Externalizable, DOM vs SAX parsers, new features in JDK 1.7 and 1.8, and Maven vs Ant.

The article concludes with a note that detailed answers are omitted to keep the reading experience concise, and invites readers to follow the public account to receive the full answers.