Ultimate Java Interview Guide: 100+ Essential Questions & Answers

This article gathers a large collection of Java interview questions and topics, organized by categories such as core Java, multithreading, JVM, databases, caching, SSM framework, operating systems, networking, distributed systems, system design, and security.

1. Java Related

ArrayList and LinkedList default capacities

Differences and advantages of ArrayList vs LinkedList, List vs Map

HashMap collision resolution methods

Why override hashCode() and equals(), and their relationship

How Object.hashCode() is calculated

Consequences of a constant hashCode() returning the same value

Default sorting algorithms used by Collections.sort and Arrays.sort

Difference between reference counting and GC root reachability analysis

Shallow copy vs deep copy

Difference between String s="abc" and new String("abc")

Where HashSet stores hashCode; effect of overriding equals without hashCode

Purpose and implementation of reflection

Java callback mechanisms

Template Method pattern

Open/Closed principle

Publish/Subscribe usage scenarios

KMP algorithm (string matching)

JMM guarantees of atomicity, visibility, ordering and memory barriers

2. Multithreading

Underlying implementation of AtomicInteger

Which is a fair lock: synchronized or ReentrantLock

Potential issues with CAS

Common classes in java.util.concurrent

Effect of calling start() on the same thread twice

Can wait() be overridden or interrupted

Thread pool implementations, four types, key parameters, and rejection policies

Thread state transitions and related APIs

Common techniques to avoid deadlocks

3. JVM

When Minor GC and Full GC occur; triggers for Full GC

Types of GC collectors; characteristics of CMS and G1

Scenarios that cause memory leaks in Java

Storage of large objects in Java

Which class loader loads rt.jar and when

When user-defined classes are loaded and by which loader

Whether two different user classes share the same class loader and why

Reason for having two Survivor spaces in the young generation

Common memory debugging tools: jmap, jstack, jconsole

Five phases of class loading: loading, verification, preparation, resolution, initialization

Pause behavior of G1 and CMS, and their impact on application latency

Data stored in stack vs heap

Heap layout: young generation, old generation, and sub‑areas of the young generation

Use cases for soft references (caching) and weak references (preventing memory leaks)

4. Database

Database indexes, full‑text indexes, and the principle of inverted indexes

Best left‑most prefix rule for indexes

Three normal forms

Principles and scenarios for pessimistic and optimistic locking

Types of joins: left, right, inner, outer, cross, Cartesian product

Recovery methods after a database crash (WAL, double write, checkpoint)

Redo log vs undo log

How ACID properties are implemented in databases

Composite indexes and when they become ineffective

Differences between relational and non‑relational databases

Resolving database deadlocks

Handling MySQL concurrency with transactions, isolation levels, and locks

MySQL MVCC mechanism and its potential issues

MySQL isolation levels and solutions for phantom reads

5. Cache Servers

Redis zSet skip‑list issues

Use cases for Redis Set

Advanced Redis features

Purpose of Redis pipeline

Handling Redis cluster failures and data migration

Redis cluster architectures

Best practices for Redis atomic operations

Implementation of Redis expiration strategies

6. SSM Related

Difference between @Autowired and @Resource in Spring

Customizing a Spring bean

Advantages of MyBatis

MyBatis transaction management

7. Operating System

Static vs dynamic linking in Linux

IO multiplexing models: select, poll, epoll

Purpose of grep and common Linux commands

Concepts and differences of virtual, logical, linear, and physical addresses

Page replacement algorithms

Process scheduling algorithms

Parent, child, orphan, and zombie processes

fork operation details

kill command usage and reasons a process may not terminate

System administration commands for memory and network monitoring

find and awk usage

Diagnosing infinite loops in Linux threads

8. Networking

Functions of the data link layer and its flow control

Layer mapping of IP, MAC, TCP, and HTTP

TCP sliding window mechanism

Reasons TCP is reliable

TCP packet fragmentation and reassembly

Differences between HTTPS and HTTP

Why HTTP is stateless

TCP three‑way handshake details

TCP congestion and flow control mechanisms

Differences between HTTP/1.0 and HTTP/2.0

Communication between computers with different IP addresses

ARP protocol

Mapping of OSI 7‑layer model to the 5‑layer model

Handling lost TCP handshake packets

9. Distributed Systems

Message queue scenarios and benefits (decoupling, async, traffic shaping)

Preventing message loss and duplicate consumption

Kafka fundamentals: idempotence, consistency, persistence, partitions, ISR, and disk‑based sequential I/O

Implementation of asynchronous queues

Estimating concurrency limits for Tomcat and MySQL

C10K problem description

Approaches for handling high concurrency

CAP, BASE, and Paxos theories

Distributed election algorithms

Understanding microservices vs. SOA

Dubbo basics: RPC, communication protocols, call flow, and failure handling

Distributed transaction strategies across multiple databases

Generating unique random values across machines

System metrics such as PV and UV

Consistent hashing and scaling of distributed caches

Forward and reverse proxy concepts

Client‑side and server‑side load‑balancing strategies

Tomcat optimization techniques

Nginx master/worker model and request processing

10. System Design

Preventing duplicate form submissions (e.g., token mechanisms)

Optimizing regex matching for massive URL white‑lists

Nginx load‑balancing strategies and adding new servers

QR‑code login flow analysis

Designing a unique UUID generation algorithm

Implementing a load‑balancing algorithm with resource distribution ratios 70/20/10

Ensuring ordered execution of three threads (T1, T2, T3)

Printing ABC sequence with three threads in a loop

11. Security

What XSS attacks are, typical manifestations, and prevention methods

The list above provides a solid foundation for preparing for Java‑related technical interviews.