• Introduction to Java
    • Expanded Knowledge: GC
    • Expanded Knowledge: Java Cross Platform
    • Installing Java Development Kit (JDK)
    • Java IDEs
    • "Hello World" Java program
    • Explanation of "Hello, World!"
    • Compile "Hello, World!"
    • Expanded Knowledge: classpath
    • Expanded Knowledge: JAVA_HOME
    • Input and Output in Java
    • Comments in Java
    • Java Variables
    • Java Data Types
    • Java Operators
    • Java Control Flow Statements
    • Loops in Java
    • Java Object-Oriented Programming (OOP)
    • The "this" Keyword in Java
    • Java Constructor
    • Java Methods
    • Static Members in Java
    • Access Modifiers in Java
    • String Handling in Java
    • Java Arrays
    • Java Collections
    • Utility classes in Java
    • Java Exception Handling
    • Java I/O
    • Multithreading and Concurrency in Java
    • Java Network Programming
    • Advanced Java Concepts
      • Generics
      • Annotations
      • Enums
      • Records
      • Sealed Classes
      • Lambda Expressions
      • Functional Interfaces
      • Stream API
      • Optional
      • Comparable & Comparator
      • Collections Best Practices
      • Thread Pools
      • Locks & Synchronizers
      • CompletableFuture
      • Virtual Threads
      • Concurrent Collections
      • NIO Basics
      • NIO.2 File API
      • Serialization
      • Character Sets & Encoding
      • JVM Architecture
      • Class Loading
      • Java Memory Model
      • Garbage Collection
      • Bytecode Basics
      • JPMS Overview
      • Module Dependencies
      • java.time API
      • Date/Time Formatting
      • Reflection Basics
      • Dynamic Proxy
      • jcmd, jmap & jstack
      • JFR & VisualVM
      • jlink & jpackage
        • Object
        • String
        • StringBuilder
        • Integer
        • Long
        • Double
        • Boolean
        • Character
        • Math
        • System
        • Runtime
        • Class
        • ClassLoader
        • Thread
        • Enum
        • Record
        • Throwable
        • Exception
        • RuntimeException
        • AutoCloseable
        • Comparable
        • Cloneable
        • ArrayList
        • LinkedList
        • HashMap
        • HashSet
        • TreeMap
        • TreeSet
        • PriorityQueue
        • ArrayDeque
        • Collections
        • Arrays
        • Optional
        • Stream
        • Collectors
        • Comparator
        • Iterator
        • UUID
        • Random
        • Properties
        • Locale
        • ResourceBundle
        • ExecutorService
        • ThreadPoolExecutor
        • ForkJoinPool
        • CompletableFuture
        • CountDownLatch
        • CyclicBarrier
        • Semaphore
        • ConcurrentHashMap
        • CopyOnWriteArrayList
        • BlockingQueue
        • AtomicInteger
        • Lock
        • ReentrantLock
        • ReadWriteLock
        • InputStream
        • OutputStream
        • Reader
        • Writer
        • FileInputStream
        • BufferedReader
        • BufferedWriter
        • ObjectInputStream
        • ObjectOutputStream
        • Serializable
        • File
        • Path
        • Files
        • PrintWriter
        • Scanner
        • Instant
        • LocalDate
        • LocalTime
        • LocalDateTime
        • ZonedDateTime
        • Duration
        • Period
        • DateTimeFormatter
        • ZoneId
        • Clock
        • URL
        • URLConnection
        • HttpURLConnection
        • Socket
        • ServerSocket
        • InetAddress
        • URI
        • HttpClient
        • MessageDigest
        • Cipher
        • KeyPair
        • Signature
        • SecureRandom
        • KeyStore
        • Certificate
      • Virtual Threads
      • Structured Concurrency
      • Scoped Values
      • CompletableFuture Advanced
      • ForkJoinPool
      • StampedLock
      • LongAdder and LongAccumulator
      • Concurrent Collections Deep Dive
      • ThreadLocal
      • Deadlock Prevention
      • Liveness Issues
      • Java Memory Model
        • Reverse a String
        • Check Palindrome
        • Count Vowels
        • Remove Duplicates
        • Find First Non-Repeating Character
        • Check Anagram
        • Compress String
        • Convert Case
        • Split and Join
        • Parse CSV
        • Validate Email Format
        • Extract Numbers from String
        • Replace Multiple Spaces
        • Trim Unicode Whitespaces
        • Generate Random String
        • Compare Version Strings
        • Escape HTML Characters
        • Format String Template
        • Levenshtein Distance
        • Longest Common Prefix
        • Sort Map by Value
        • Merge Two Lists
        • Remove Duplicates from List
        • Find Top K Elements
        • Flatten Nested List
        • Partition List
        • Rotate List Elements
        • Find Intersection of Lists
        • Convert List to Map
        • Group List by Property
        • Immutable Collection Copy
        • Shuffle List Securely
        • Find Missing Number
        • Find Duplicate Number
        • Sliding Window Maximum
        • Merge Sorted Arrays
        • Find Median of Two Sorted Arrays
        • Subarray Sum Equals K
        • Product Array Except Self
        • Next Permutation
        • Read File to String
        • Write String to File
        • Copy File
        • Watch Directory Changes
        • List Files Recursively
        • Calculate File Hash
        • Compress with GZIP
        • Parse CSV File
        • Read Properties File
        • Create Temp File
        • Delete Directory Recursively
        • Get File Extension
        • Monitor Log File
        • Memory-Mapped File Read
        • Stream Large File
        • Compare Two Files
        • Find Largest File in Directory
        • Atomic File Write
        • Parse Date String
        • Format Date Output
        • Calculate Age from Birthdate
        • Add Business Days
        • Find Days Between Dates
        • Convert Timezone
        • Get Start of Day
        • Get End of Month
        • Check Leap Year
        • Schedule Task with Delay
        • Cron Expression Parsing
        • Measure Execution Time
        • Format Duration Human-Readable
        • Compare Dates Ignoring Time
        • Get Week Number
        • Find Next Weekday
        • Handle Daylight Saving Time
        • Filter and Collect
        • Group By with Counting
        • FlatMap Nested Lists
        • Reduce to Single Value
        • Find Max by Property
        • Partition by Predicate
        • Custom Collector
        • Parallel Stream Best Practices
        • Stream from Iterator
        • Infinite Stream Generate
        • Distinct by Property
        • Sort with Comparator Chain
        • Join Strings with Stream
        • Convert Stream to Array
        • Peek for Debugging
        • Optional with Stream
        • Stream Exception Handling
        • Primitive Streams
        • Producer-Consumer Queue
        • Rate Limiter Implementation
        • Simple Thread Pool
        • Parallel File Processing
        • CountDownLatch Barrier
        • Read-Write Lock Cache
        • Async Task Composition
        • Timeout on Future
        • Graceful Shutdown
        • Thread-Safe Singleton
        • Copy-On-Write Event Listeners
        • StampedLock Optimistic Read
        • Simple HTTP Server
        • Download File from URL
        • Send HTTP POST Request
        • Parse JSON Response
        • Check URL Reachability
        • WebSocket Client
        • Resolve DNS Lookup
        • Scan Open Ports
        • Proxy Configuration
        • SSL Certificate Validation
        • Retry with Exponential Backoff
        • Hash Password with BCrypt
        • Generate Secure Token
        • AES Encrypt Decrypt
        • RSA Key Pair Generation
        • HMAC Signature Verification
        • Generate UUID
        • Secure Random Numbers
        • Mask Sensitive Data in Logs
        • Validate Input Sanitization
        • Parse JWT Claims
        • Certificate Pinning
        • Constant-Time String Compare
        • Bytecode Instruction: aload/aload_0
        • Bytecode Instruction: invokevirtual
        • Bytecode Instruction: invokespecial
        • Bytecode Instruction: invokestatic
        • Bytecode Instruction: invokeinterface
        • Bytecode Instruction: invokedynamic
        • Bytecode Instruction: getfield/putfield
        • Bytecode Instruction: getstatic/putstatic
        • Bytecode Instruction: ifeq/ifne
        • Bytecode Instruction: goto
        • Bytecode Instruction: tableswitch
        • Bytecode Instruction: lookupswitch
        • Bytecode Instruction: new
        • Bytecode Instruction: checkcast
        • Bytecode Instruction: monitorenter/monitorexit
        • Bytecode Instruction: athrow
        • Bytecode Instruction: ldc
        • Bytecode Instruction: bipush/sipush
        • Class Loader Hierarchy
        • Bootstrap ClassLoader
        • Extension ClassLoader
        • Application ClassLoader
        • Bytecode Verification
        • Constant Pool
        • Method Area
        • PC Register
        • Native Method Interface
        • JNI Basics
        • JVMTI Overview
        • Agent Attach
        • Instrumentation API
        • Unsafe Class
        • VarHandle API
        • MethodHandle API
        • Lambda Metafactory
        • javac Compilation Process
        • Annotation Processing
        • Compiler Plugins
        • Incremental Compilation
        • Preview Features
        • Release Flag
        • Cross-Compilation
        • Module Compilation
        • Record Compilation
        • Pattern Matching Compilation
        • String Concat Factory
      • jlink Module Linking
      • jdeps Dependency Analysis
      • jdeprscan Deprecation Scanner
      • jconsole Monitoring
      • jvisualvm Profiling
      • jshell Scripting
      • keytool Certificate Management
      • jarsigner JAR Signing
      • jar Command
      • javap Disassembler
      • javadoc Generation
      • serialver Serial Version
      • native2ascii Converter
      • rmic RMI Compiler
      • apt Annotation Processing
      • Why is String immutable?
      • Why main method is static?
      • Pass by value or reference?
      • Difference between == and equals?
      • Why char[] for passwords?
      • What is autoboxing?
      • Integer cache -128 to 127
      • Why override hashCode with equals?
      • Checked vs unchecked?
      • Final vs finally vs finalize?
      • Abstract class vs interface?
      • Composition vs inheritance?
      • Static vs instance methods?
      • Override vs overload?
      • Deep copy vs shallow copy?
      • Why use interfaces?
      • What is type erasure?
      • Why Optional not for fields?
      • When to use parallel streams?
      • Why avoid float for money?
      • ArrayList vs LinkedList
      • HashMap vs TreeMap
      • HashSet vs TreeSet
      • String vs StringBuilder
      • Interface vs Abstract Class
      • Composition vs Inheritance
      • Stack vs Heap Memory
      • Process vs Thread
      • Runnable vs Callable
      • synchronized vs Lock
      • JVM vs JRE vs JDK
      • Virtual Threads vs Platform Threads
      • Records vs Classes
      • Sealed Classes vs Enum
      • var vs Explicit Types
      • Prefer Immutable Objects
      • Use Optional Correctly
      • Avoid Null Returns
      • Validate Method Arguments
      • Use Meaningful Names
      • Keep Methods Short
      • Single Responsibility Principle
      • Fail Fast Validation
      • Use Standard Exceptions
      • Close Resources with Try-With-Resources
      • Prefer Composition Over Inheritance
      • Program to Interfaces
      • Minimize Mutability
      • Use Enum for Constants
      • Avoid Raw Types
      • Use Bounded Wildcards
      • Prefer Method References
      • Use Stream API Idiomatically
      • Avoid Parallel Streams by Default
      • Use Concurrent Collections
      • Minimize Lock Scope
      • Avoid Thread Groups
      • Use Executor Framework
      • Handle InterruptedException Properly
      • Prefer Time API over Date
      • Use UTC for Storage
      • Avoid Calendar Class
      • Use BigDecimal for Money
      • Compare BigDecimal with compareTo
      • Cache Expensive Computations
      • Use Lazy Initialization Carefully
      • Avoid Premature Optimization
      • Profile Before Tuning
      • Use Appropriate Collection
      • Size Collections When Known
      • Override equals and hashCode Together
      • Make Classes Immutable When Possible
      • Use Builder for Many Parameters
      • Avoid Excessive Logging
      • Use Structured Logging
      • Never Log Passwords
      • Sanitize User Input
      • Use Parameterized Queries
      • Validate All External Input
      • Principle of Least Privilege
      • Keep Dependencies Updated
      • Use Dependency Injection
      • Separate Configuration from Code
      • Write Testable Code
      • Aim for High Cohesion
      • Reduce Coupling
      • Document Public APIs
      • Use JavaDoc for Libraries
      • Follow Code Conventions
      • Use Static Analysis Tools
      • Review Code Regularly
      • Refactor Incrementally
      • Delete Dead Code
      • Avoid Magic Numbers
      • Use Constants Class
      • Handle Errors at Right Level
      • Use Custom Exceptions Sparingly
      • Return Empty Collections Not Null
      • Defensive Copy for Mutable Args
      • Use CopyOnWrite for Read-Heavy
      • Prefer ArrayList over Vector
      • Use EnumSet and EnumMap
      • Avoid Double-Checked Locking
      • Use volatile for Visibility
      • Document Thread Safety
      • Limit Serialization
      • Use transient for Sensitive Fields
      • Prefer Interface Serialization
      • Version Serializable Classes
      • Use Module System for Encapsulation
      • Export Only Public API
      • Avoid Deep Inheritance Hierarchies
      • Favor Delegation Over Inheritance
      • Use Records for Data Carriers
      • Use Sealed Classes for Restricted Hierarchies
    • JPA vs MyBatis
    • JPA vs JDBC
    • Redis vs Memcached
    • HikariCP vs Druid
      • SELECT Queries
      • SQL Joins
      • Subqueries
      • Aggregation
      • Indexes
      • SQL Transactions
      • Database Normalization
      • EXPLAIN Plans
      • Stored Procedures
      • PostgreSQL with Java
      • MySQL with Java
      • Flyway Basics
      • Flyway with Spring Boot
      • Liquibase Basics
      • Liquibase Changesets
      • Migration Best Practices
        • Query Plan Analysis
        • Index Selection Strategy
        • Covering Index Design
        • Partial Index Usage
        • Materialized Views
        • Query Rewriting
        • Connection Pool Monitoring
        • Slow Query Log Analysis
        • Batch Insert Optimization
        • Pagination Performance
        • Cursor-Based Pagination
        • Read Replica Routing
        • Redis Pub/Sub Patterns
        • Redis Pipeline Optimization
        • Redis Cluster Sharding
        • MongoDB Aggregation Pipeline
        • MongoDB Index Strategies
        • MongoDB Transactions
        • Elasticsearch Java Client
        • Cassandra Java Driver
        • DynamoDB Enhanced Client
        • Neo4j Java Driver
        • InfluxDB Java Client
        • Couchbase Java SDK
        • JPA Entity Graphs
        • Hibernate Envers Auditing
        • Hibernate Filters
        • Second Level Cache Config
        • Query Cache Setup
        • Batch Fetch Size Tuning
        • Hibernate Interceptors
        • Custom Hibernate Types
        • Multi-Tenant Hibernate
        • JPA Attribute Converters
        • Hibernate Spatial
        • Blaze Persistence
      • JPA vs MyBatis?
      • When to use NoSQL?
      • Connection pool size?
      • What is N+1?
      • Lazy vs eager loading?
      • What is ACID?
      • Isolation levels explained?
      • Index when to add?
      • VARCHAR vs CHAR?
      • Primary key vs unique key?
      • What is ORM?
      • Migration tool choice?
      • Redis vs Memcached?
      • When to denormalize?
      • What is sharding?
      • Read replica lag?
      • Optimistic vs pessimistic lock?
      • What is two-phase commit?
      • PreparedStatement why?
      • Batch insert how?
      • JDBC Overview
      • Database Connection
      • Executing SQL Queries
      • Handling Result Sets
      • Prepared Statements in JDBC
      • Transaction Management
      • JPA Overview
      • Hibernate Basics
      • Entity Relationships
      • JPQL and Criteria API
      • HikariCP
      • Druid Connection Pool
      • Redis with Jedis
      • Redis with Lettuce
      • MongoDB Java Driver
      • MyBatis Basics
      • MyBatis SQL Mapping
      • MyBatis Dynamic SQL
    • Kafka vs RabbitMQ
    • Kafka vs JMS
      • JMS Overview
      • JMS Producer and Consumer
      • Kafka Overview
      • Kafka Producers and Consumers
      • Kafka Streams
      • RabbitMQ Overview
      • Exchanges and Queues
      • Messaging Patterns
        • Kafka Exactly-Once Semantics
        • Kafka Connect
        • Kafka Schema Registry
        • Kafka KSQL
        • Kafka MirrorMaker
        • Kafka ACLs and Security
        • Kafka Performance Tuning
        • Kafka Partition Strategy
        • Kafka Consumer Rebalance
        • Kafka Transaction API
        • Kafka Compacted Topics
        • Kafka Monitoring
        • RabbitMQ Clustering
        • RabbitMQ Shovel Plugin
        • RabbitMQ Federation
        • RabbitMQ Streams
        • RabbitMQ Quorum Queues
        • RabbitMQ Performance Tuning
        • RabbitMQ TLS Configuration
        • RabbitMQ Management API
        • Event Carried State Transfer
        • Event Notification Pattern
        • Claim Check Pattern
        • Message Channel Bridge
        • Content Enricher Pattern
        • Message Router Pattern
        • Wire Tap Pattern
        • Message Store Pattern
        • Polling Consumer Pattern
    • Spring vs Jakarta EE
    • Spring MVC vs WebFlux
      • IoC & Dependency Injection
      • Aspect-Oriented Programming
      • Bean Lifecycle
      • Spring MVC
      • Auto-Configuration
      • Spring Boot Starters
      • Spring Boot Actuator
      • Deployment
      • Spring Cloud Overview
      • Spring Cloud Config
      • Spring Cloud Gateway
      • Service Discovery
      • Spring Data JPA
      • Spring Data Redis
      • Spring Data MongoDB
      • Spring Batch Introduction
      • Job Configuration
      • Chunk Processing
      • Partitioning
      • Scheduling Batch Jobs
      • Spring Integration Introduction
      • Channels and Adapters
      • Transformers and Filters
      • Integration Gateways
      • OAuth2 Authorization Server
      • SAML Integration
      • LDAP Authentication
      • Advanced Method Security
      • CSRF and CORS
      • Session Management
        • BeanFactory vs ApplicationContext
        • BeanPostProcessor
        • BeanFactoryPostProcessor
        • ApplicationEvent Publishing
        • Conditional Annotations
        • Profile Configuration
        • PropertySource and Environment
        • SpEL Advanced
        • Resource Loading
        • FactoryBean Pattern
        • Autowired Resolution
        • Circular Dependency Solutions
        • Spring Lifecycle Callbacks
        • JSR-250 Annotations
        • Custom Scope
        • Custom Auto-Configuration
        • ConditionalOnProperty
        • Spring Boot Starters Creation
        • Actuator Custom Endpoints
        • Actuator Security
        • Spring Boot DevTools
        • Configuration Properties Validation
        • Multi-Module Spring Boot
        • Spring Boot Native Image
        • Graceful Shutdown
        • Custom Error Pages
        • Spring Boot Banner
        • Log Configuration
        • External Config Priority
        • Spring Cloud Config Encryption
        • Spring Cloud Bus
        • Spring Cloud Sleuth Migration
        • Resilience4j Advanced
        • Spring Cloud Stream
        • Spring Cloud Function
        • Service Mesh Integration
        • Spring Cloud Kubernetes
        • Spring Cloud AWS
        • Spring Cloud GCP
        • Distributed Tracing with Micrometer
        • Spring Cloud Contract
        • Spring Data REST
        • Spring Data Projections
        • QueryDSL Integration
        • Spring Data Auditing
        • Custom Repository Implementation
        • Spring Data JDBC
        • Spring Data Envers
        • Multi-Tenant Data Access
        • Spring Cache Abstraction
        • Transaction Propagation Deep Dive
        • Read-Only Transactions
        • Programmatic Transactions
        • Spring MVC Exception Handling
        • Content Negotiation
        • HandlerInterceptor
        • WebMvcConfigurer Customization
        • CORS Configuration
        • File Upload Handling
        • Server-Sent Events
        • Spring HATEOAS
        • API Versioning Strategies
        • Spring Validation Groups
        • Custom Argument Resolver
        • Thymeleaf Integration
        • Build a REST API with Spring Boot
        • Add Database with Spring Data JPA
        • Secure API with Spring Security
        • Add Validation to REST API
        • Handle Exceptions Globally
        • Add Pagination to API
        • Upload Files with Spring MVC
        • Send Email with Spring Boot
        • Schedule Tasks with Spring
        • Add Caching to Spring Boot App
        • Write Integration Tests
        • Deploy Spring Boot to Docker
        • Production-Ready Spring Boot
        • Configure Logging for Production
        • Health Checks and Monitoring
        • Database Connection Pool Tuning
        • Graceful Shutdown Configuration
        • Profile-Based Configuration
        • Secrets Management
        • Rate Limiting API
        • API Documentation with OpenAPI
        • Performance Testing Spring App
        • Memory Tuning Spring Boot
        • Zero-Downtime Deployment
      • What is IoC?
      • What is DI?
      • Component vs Bean?
      • Autowired by type or name?
      • Why constructor injection?
      • What is AOP?
      • What is Spring Boot?
      • Auto-configuration how it works?
      • What is Spring Cloud?
      • RestTemplate vs WebClient?
      • JPA vs JDBC?
      • What is @Transactional?
      • Bean scope types?
      • How to handle exceptions?
      • Spring Security filter order?
      • What is Actuator?
      • Profile vs Property?
      • What is Feign?
      • Circuit breaker when to use?
      • Spring vs Spring Boot?
    • OAuth2 vs SAML
    • JWT vs Session
      • Authentication
      • Authorization
      • OAuth2 Integration
      • Apache Shiro Basics
      • Shiro Authorization
      • JAAS Basics
      • JAAS Policy
      • OAuth 2.0 Overview
      • JWT Basics
        • OWASP Top 10 Overview
        • SQL Injection Prevention
        • XSS Prevention
        • CSRF Protection
        • Broken Authentication
        • Sensitive Data Exposure
        • Security Misconfiguration
        • Insecure Deserialization
        • Insufficient Logging
        • Server-Side Request Forgery
        • XML External Entities
        • Broken Access Control
        • Multi-Factor Authentication
        • Passwordless Authentication
        • Magic Link Login
        • Social Login Integration
        • API Key Authentication
        • Mutual TLS
        • Certificate-Based Auth
        • Biometric Authentication
        • Session Fixation Prevention
        • Remember Me Implementation
        • Account Lockout Policy
        • Password Reset Flow
        • Symmetric Encryption AES
        • Asymmetric Encryption RSA
        • Digital Signatures
        • Key Derivation PBKDF2
        • Argon2 Password Hashing
        • Secure Key Storage
        • TLS Configuration
        • Certificate Management
        • Hashing Algorithms
        • Random Number Generation
        • Key Rotation Strategy
        • Keycloak Integration
        • Auth0 with Spring Boot
        • Okta Integration
        • Spring Security OAuth2 Resource Server
        • Spring Security OAuth2 Client
        • Penetration Testing Basics
        • Dependency Vulnerability Scanning
        • OWASP Dependency Check
    • Maven vs Gradle
      • Maven Basics
      • Maven Dependencies
      • Maven Plugins
        • Maven Lifecycle Phases
        • Custom Maven Plugin
        • Maven Profile Activation
        • Maven Dependency Exclusion
        • Maven BOM Management
        • Maven Release Plugin
        • Maven Site Generation
        • Maven Archetype
        • Maven Toolchains
        • Maven Reactor Build
        • Maven CI Friendly Versions
        • Maven Flatten Plugin
        • Gradle Task Dependencies
        • Gradle Custom Plugin
        • Gradle Plugin Portal
        • Gradle Configuration Cache
        • Gradle Build Scan
        • Gradle Dependency Resolution
        • Gradle Publishing
        • Gradle Test Fixtures
        • Gradle Toolchain Support
        • Gradle Lazy Configuration
        • Gradle Worker API
        • Gradle Enterprise
      • Gradle Basics
      • Gradle Dependencies
    • JUnit 4 vs JUnit 5
    • Mockito vs EasyMock
      • JUnit 5 Basics
      • Parameterized Tests
      • JUnit 5 Extensions
      • Mockito Basics
      • Mockito Advanced
      • Testcontainers Basics
      • AssertJ
      • WireMock
      • REST Assured
      • TestNG
      • Pact Contract Testing
      • ArchUnit
      • JMH Benchmarking
      • Cucumber BDD
      • Selenium WebDriver
      • Performance Testing
      • Singleton
      • Factory Method
      • Abstract Factory
      • Builder
      • Prototype
      • Object Pool
      • Adapter
      • Decorator
      • Facade
      • Proxy
      • Composite
      • Bridge
      • Flyweight
      • Observer
      • Strategy
      • Template Method
      • Command
      • Iterator
      • State
      • Mediator
      • Memento
      • Visitor
      • Chain of Responsibility
      • Interpreter
    • REST vs GraphQL
    • Tomcat vs Jetty
      • Servlet Basics
      • Filters and Listeners
      • JSP Basics
      • RESTful Design
      • JAX-RS
        • Async Servlet Processing
        • Servlet 6.0 Features
        • Multipart Config
        • Servlet Security Constraints
        • Request Dispatcher Types
        • Servlet Container Initializer
        • Programmatic Servlet Registration
        • HTTP/2 Server Push
        • Web Fragment
        • HATEOAS Implementation
        • API Pagination Patterns
        • Content Negotiation
        • ETag and Conditional Requests
        • API Idempotency Keys
        • Problem Details RFC 7807
        • OpenAPI Specification
        • Swagger UI Integration
        • API Gateway Patterns
        • GraphQL with Java
        • WebSocket REST Hybrid
        • Server-Sent Events API
        • Thymeleaf Templates
        • FreeMarker Templates
        • Vaadin Framework
        • JSF Components
        • Struts Legacy Migration
        • Play Framework Overview
        • Micronaut Web
        • Quarkus REST
        • Helidon SE
        • CORS Deep Dive
        • JWT for SPA
        • OAuth2 PKCE Flow
        • Session vs Token Auth
        • React with Java Backend
        • Vue with Java Backend
        • Mobile API Design
    • Monolith vs Microservices
    • REST vs gRPC
      • Microservices Overview
      • Service Communication
      • Apache Dubbo Basics
      • gRPC Java Basics
        • Synchronous vs Asynchronous
        • Event-Driven Communication
        • Request-Response Pattern
        • Publish-Subscribe Pattern
        • Message Routing
        • Content-Based Router
        • Message Filter
        • Claim Check Pattern
        • Correlation ID Pattern
        • Circuit Breaker Pattern
        • Retry Pattern
        • Timeout Pattern
        • Bulkhead Pattern
        • Fallback Pattern
        • Rate Limiter Pattern
        • Health Check Pattern
        • Self-Healing Pattern
        • Graceful Degradation
        • Database per Service
        • Shared Database Anti-Pattern
        • Event Sourcing Pattern
        • CQRS Pattern
        • Saga Orchestration
        • Saga Choreography
        • Eventual Consistency
        • API Composition
        • Strangler Fig Pattern
        • Anti-Corruption Layer
        • Blue-Green Deployment
        • Canary Deployment
        • Feature Flags
        • Service Mesh Overview
        • Sidecar Pattern
        • Ambassador Pattern
        • Adapter Pattern for Legacy
        • Backend for Frontend
        • API Gateway Pattern
    • Caffeine vs Redis Cache
      • Local Cache
      • Distributed Cache
      • Distributed Lock
      • Distributed Transactions
      • Seata
        • Raft Algorithm
        • Paxos Overview
        • Leader Election
        • Quorum Systems
        • Vector Clocks
        • Lamport Timestamps
        • Conflict-Free Replicated Data Types
        • Gossip Protocol
        • ZooKeeper Basics
        • etcd Usage
        • Consul Service Discovery
        • Redis Distributed Lock Advanced
        • Redlock Algorithm
        • Leader Election with Redis
        • Distributed Semaphore
        • Barrier Synchronization
        • Exactly-Once Semantics
        • At-Least-Once Delivery
        • At-Most-Once Delivery
        • Message Ordering Guarantees
        • Dead Letter Queue Design
        • Event Schema Evolution
        • Message Idempotency
        • Outbox Pattern Advanced
        • Inbox Pattern
        • Consistent Hashing Ring
        • Data Partitioning Strategies
        • Hot Partition Problem
        • Read Repair
        • Hinted Handoff
        • Anti-Entropy Repair
        • Multi-Region Replication
        • Conflict Resolution Strategies
    • ZGC vs G1 GC
      • Heap Tuning
      • GC Tuning
      • Profiling Basics
      • async-profiler
        • JIT Compilation Tiers
        • Escape Analysis
        • Inline Optimization
        • Safepoint Mechanism
        • GC Roots Analysis
        • Metaspace Tuning
        • Direct Memory Tuning
        • Code Cache Tuning
        • Compressed OOPs
        • TLAB Allocation
        • Object Layout
        • String Deduplication
        • G1 GC Deep Dive
        • ZGC Configuration
        • Shenandoah GC
        • Parallel GC Tuning
        • CMS Legacy GC
        • GC Log Analysis
        • GC Causes and Fixes
        • Allocation Rate Optimization
        • Humongous Objects G1
        • GC Pause Targeting
        • Connection Pool Sizing
        • Thread Pool Tuning
        • Cache Hit Rate Optimization
        • N+1 Query Fix
        • Batch Processing Optimization
        • Lazy Loading Strategy
        • Object Pooling
        • String Concatenation Performance
        • Collection Sizing
        • Stream vs Loop Performance
        • Reflection Performance
        • Serialization Performance
        • JFR Event Streaming
        • JMC Analysis
        • Heap Dump Analysis MAT
        • Thread Dump Analysis
        • Latency Percentiles
        • Apdex Score
        • SLI and SLO Definition
        • Alerting Best Practices
        • Performance Budget
      • Java SE Fundamentals Interview
      • Collections and Concurrency Interview
      • JVM Interview Questions
      • Spring Interview Questions
      • System Design Basics
        • Load Balancing Strategies
        • Caching Layers
        • Database Sharding
        • Replication Strategies
        • Consistent Hashing
        • Rate Limiting Design
        • Message Queue Design
        • CDN Architecture
        • API Gateway Design
        • Microservices vs Monolith
        • Event-Driven Architecture
        • CQRS Pattern
        • Event Sourcing
        • Saga Pattern Design
        • Circuit Breaker Design
        • Bulkhead Pattern
        • Idempotency Design
        • Pagination Strategies
        • Design URL Shortener
        • Design Twitter Feed
        • Design Chat System
        • Design Rate Limiter
        • Design Web Crawler
        • Design Notification System
        • Design E-Commerce Platform
        • Design Ride Sharing Service
        • Design Video Streaming
        • Design Search Autocomplete
        • Design Distributed Cache
        • Design Payment System
        • Design File Storage System
        • Design Ticket Booking
        • Design News Feed
        • Design Leaderboard
        • Design Analytics Platform
        • Design Email Service
        • Design Recommendation Engine
        • Design Map Reduce System
        • Design Key-Value Store
        • Design Unique ID Generator
        • Design Hit Counter
        • Design Logger
        • Design Task Scheduler
        • Design API Rate Limiter
        • Design Parking Lot
        • Design Vending Machine
        • Design Elevator System
        • Design Library Management
        • Design Hotel Booking
        • Design Food Delivery
        • Two Sum
        • 3Sum
        • Maximum Subarray
        • Merge Intervals
        • Product of Array Except Self
        • Rotate Array
        • Container With Most Water
        • Trapping Rain Water
        • Reverse Linked List
        • Merge Two Sorted Lists
        • Linked List Cycle
        • Remove Nth Node From End
        • Reorder List
        • Maximum Depth of Binary Tree
        • Invert Binary Tree
        • Validate BST
        • LCA of Binary Tree
        • Binary Tree Level Order
        • Serialize and Deserialize
        • Number of Islands
        • Course Schedule
        • Clone Graph
        • Word Ladder
        • House Robber
        • Coin Change
        • LIS
        • Word Break
        • Decode Ways
        • Surrounded Regions
        • Walls and Gates
        • Rotting Oranges
        • 01 Matrix
        • Shortest Path in Binary Matrix
        • As Far from Land as Possible
        • Pacific Atlantic Water Flow
        • All Nodes Distance K in BST
        • Sum Root to Leaf Numbers
        • Path Sum II
        • Binary Tree Right Side View
        • Average of Levels in Binary Tree
        • Cousins in Binary Tree
        • Distribute Coins in Binary Tree
        • Amount of Time for Tree to Burn
        • Maximum Width of Binary Tree
        • Populating Next Right Pointers
        • Flatten Binary Tree to Linked List
        • Construct Binary Tree from Preorder Inorder
        • Serialize Deserialize BST
        • Two Sum II Sorted
        • 3Sum Closest
        • 4Sum
        • Remove Duplicates Sorted Array
        • Remove Element
        • Move Zeroes
        • Sort Colors Dutch Flag
        • Valid Palindrome II
        • Boats to Save People
        • Partition Labels
        • Minimum Length String After Deletes
        • Reverse String
        • Reverse Vowels
        • Is Subsequence
        • Shortest Word Distance
        • Squares of Sorted Array
        • Backspace String Compare
        • Interval List Intersections
        • Merge Sorted Array In Place
        • Find Duplicate Number Floyd
        • Reverse Integer
        • Palindrome Number
        • Pow(x, n)
        • Sqrt(x)
        • Happy Number
        • Count Primes
        • Power of Three
        • Excel Sheet Column Number
        • Factorial Trailing Zeroes
        • Counting Bits
        • Missing Number
        • Single Number
        • Single Number II
        • Sum of Two Integers
        • Divide Two Integers
        • Fraction to Recurring Decimal
        • Max Points on a Line
        • Valid Square
        • Rectangle Overlap
        • Maximum Average Subarray
        • Max Consecutive Ones III
        • Longest Substring Without Repeating
        • Longest Repeating Character Replacement
        • Permutation in String
        • Minimum Window Substring
        • Sliding Window Maximum
        • Minimum Size Subarray Sum
        • Subarray Product Less Than K
        • Fruit Into Baskets
        • Longest Continuous Subarray
        • Replace Substring for Balanced String
        • Grumpy Bookstore Owner
        • Get Equal Substrings Within Budget
        • Number of Substrings Containing All
        • Minimum Window Subsequence
        • Max Vowels in Substring
        • Frequency of Most Frequent Element
        • Minimum Recolors to Get K Black Blocks
        • Maximum Points from Cards
        • Search Insert Position
        • Find First and Last Position
        • Search 2D Matrix
        • Find Minimum in Rotated Array
        • Find Peak Element
        • Search in Rotated Array II
        • Median of Two Sorted Arrays
        • Split Array Largest Sum
        • Koko Eating Bananas
        • Capacity to Ship Packages
        • Minimum Limit of Balls in Bag
        • Maximum Running Time
        • Minimum Speed to Arrive on Time
        • Maximum Value at Given Index
        • Minimum Absolute Sum Diff
        • Minimum Number of Days to Make Bouquets
        • Minimum Time to Complete Trips
        • Maximum Number of Removable Characters
        • Minimum Size Subarray Sum BS
        • Find K Closest Elements
      • Tell Me About Yourself
      • Strengths and Weaknesses
      • Conflict Resolution
      • Leadership Examples
      • Failure and Learning
      • Why This Company
      • Salary Negotiation
      • ACID Properties
      • Normalization
      • Indexing Strategies
      • Query Optimization
      • Database Sharding
      • Replication
      • CAP Theorem
      • SQL vs NoSQL
        • HashMap Interview Questions
        • ConcurrentHashMap Questions
        • ArrayList vs LinkedList
        • Fail-Fast vs Fail-Safe
        • Comparable vs Comparator
        • Iterator vs ListIterator
        • HashMap Internal Working
        • HashSet vs TreeSet
        • Queue and Deque Questions
        • Thread Lifecycle Questions
        • Synchronized vs Lock
        • Volatile Keyword
        • ThreadLocal Questions
        • Executor Framework
        • Deadlock Prevention
        • Producer Consumer Problem
        • Print Odd Even
        • Thread Pool Sizing
        • CountDownLatch Questions
        • Semaphore Use Cases
        • ReadWriteLock Questions
        • IoC Container Questions
        • Bean Scope Questions
        • Transaction Management
        • Spring Boot Auto-Config
        • Spring MVC Flow
        • Spring Security Filter Chain
        • Spring Data JPA Questions
        • Spring Cloud Questions
        • RestTemplate vs WebClient
        • Spring AOP Questions
        • Spring Boot Actuator
        • Spring Profiles
        • JDBC vs JPA
        • N+1 Query Problem
        • Database Indexing
        • Transaction Isolation
        • Connection Pool Tuning
        • SQL Join Types
        • Database Normalization
        • Optimistic vs Pessimistic Lock
        • Database Migration Tools
        • Read Replicas
        • Design Parking Lot
        • Design Vending Machine
        • Design Chess Game
        • Design Deck of Cards
        • Design In-Memory Cache
        • Design Logger
        • Design Stack Overflow
        • Design Amazon Locker
        • Design Meeting Scheduler
        • Design Snake and Ladder
        • Design Tic Tac Toe
        • Design Connect Four
        • Problem: Valid Anagram
        • Problem: Group Anagrams
        • Problem: Top K Frequent Elements
        • Problem: Sort Colors
        • Problem: Majority Element
        • Problem: Find All Duplicates
        • Problem: Set Matrix Zeroes
        • Problem: Spiral Matrix
        • Problem: Valid Binary Search Tree
        • Problem: Kth Smallest in BST
        • Problem: Construct BST from Preorder
        • Problem: Lowest Common Ancestor BST
        • Problem: Path Sum
        • Problem: Diameter of Binary Tree
        • Problem: Subtree of Another Tree
        • Problem: Balanced Binary Tree
        • Problem: Number of Connected Components
        • Problem: Graph Valid Tree
        • Problem: Redundant Connection
        • Problem: Find Eventual Safe States
        • Problem: All Paths From Source to Target
        • Problem: Minimum Height Trees
        • Problem: Reconstruct Itinerary
        • Problem: Evaluate Division
        • Problem: Longest Palindromic Substring
        • Problem: Palindromic Substrings Count
        • Problem: Longest Repeating Character Replacement
        • Problem: Minimum Window Substring
        • Problem: Valid Palindrome II
        • Problem: Decode String
        • Problem: String to Integer
        • Problem: Implement strStr()
        • Problem: Climbing Stairs
        • Problem: Min Cost Climbing Stairs
        • Problem: House Robber II
        • Problem: Delete and Earn
        • Problem: Maximum Product Subarray
        • Problem: Best Time to Buy Stock
        • Problem: Best Time to Buy Stock II
        • Problem: Best Time to Buy Stock III
        • Problem: Permutations II
        • Problem: Combination Sum
        • Problem: Combination Sum II
        • Problem: Subsets II
        • Problem: Letter Combinations Phone
        • Problem: Palindrome Partitioning
        • Problem: Restore IP Addresses
        • Problem: Partition to K Equal Sum Subsets
      • How to prepare for Java interview?
      • System design interview tips?
      • Behavioral interview STAR method?
      • How to explain projects?
      • Salary negotiation tips?
      • Remote interview best practices?
      • Whiteboard vs laptop coding?
      • How to handle unknown questions?
      • Follow-up questions to ask?
      • Red flags in interviews?
      • Junior vs senior expectations?
      • How long to prepare?
      • Mock interview benefits?
      • Portfolio for backend dev?
      • Open source contribution value?
      • Certification worth it?
    • Netty vs Apache Mina
    • Lombok vs Manual Boilerplate
      • Lombok Basics
      • Guava Basics
      • Netty Basics
      • Netty Pipeline
        • Commons Lang3
        • Commons IO
        • Commons Collections4
        • Commons Codec
        • Commons Compress
        • Commons CSV
        • Commons Math
        • Commons Text
        • Commons Pool
        • Commons Configuration
        • Commons BeanUtils
        • Commons CLI
        • Awaitility
        • Instancio
        • Datafaker
        • GreenMail
        • WireMock Spring Boot
        • Testcontainers PostgreSQL
        • Testcontainers Kafka
        • Testcontainers Redis
        • Embedded MongoDB
        • H2 Database Testing
        • DbUnit
        • Flyway Test
        • Maven Enforcer Plugin
        • Maven Shade Plugin
        • Maven Assembly Plugin
        • Gradle Kotlin DSL
        • Gradle Composite Builds
        • Gradle Convention Plugins
        • Gradle Version Catalogs Advanced
        • Maven BOM Import
        • Multi-Module Maven
        • Gradle Build Cache
        • Maven Wrapper
        • Gradle Wrapper
        • Jackson Annotations
        • Jackson Custom Serializer
        • Jackson Polymorphic Types
        • Gson Type Adapters
        • Protobuf Java
        • Avro Java
        • Kryo Serialization
        • Java Serialization
        • JSON Schema Validation
      • Bubble Sort
      • Selection Sort
      • Insertion Sort
      • Merge Sort
      • Quick Sort
      • Heap Sort
      • Counting Sort
      • Radix Sort
      • Shell Sort
      • TimSort
      • Linear Search
      • Binary Search
      • Binary Search Variations
      • Interpolation Search
      • Exponential Search
      • Ternary Search
      • Jump Search
      • ArrayList Internals
      • Linked List
      • Stack
      • Queue
      • Deque
      • HashMap Internals
      • HashSet
      • TreeMap
      • TreeSet
      • Priority Queue
      • Binary Tree
      • Binary Search Tree
      • AVL Tree
      • Red-Black Tree
      • Trie
      • Segment Tree
      • Fenwick Tree
      • Union-Find
      • LRU Cache
      • Graph Representation
      • Breadth-First Search
      • Depth-First Search
      • Topological Sort
      • Dijkstra's Algorithm
      • Bellman-Ford
      • Floyd-Warshall
      • Kruskal's Algorithm
      • Prim's Algorithm
      • Cycle Detection
      • Connected Components
      • Bipartite Graph Check
    • Dynamic Programming Introduction
    • Memoization
    • Tabulation
    • Fibonacci DP
    • Climbing Stairs
    • Coin Change
    • Coin Change II
    • Longest Increasing Subsequence
    • Longest Common Subsequence
    • Edit Distance
    • 0/1 Knapsack
    • Unbounded Knapsack
    • House Robber
    • Unique Paths
    • Maximum Subarray
    • Palindromic Substring
    • Word Break
    • Decode Ways
      • KMP Algorithm
      • Rabin-Karp
      • Longest Palindrome
      • Anagram Detection
      • String Compression
      • String to Integer (atoi)
      • Valid Parentheses
      • Minimum Window Substring
      • Group Anagrams
      • Recursion Basics
      • Tail Recursion
      • Backtracking Introduction
      • Permutations
      • Combinations
      • Subsets
      • N-Queens
      • Sudoku Solver
      • Word Search
      • Generate Parentheses
      • Jakarta EE Overview
      • CDI (Contexts and Dependency Injection)
      • Bean Validation
      • Jakarta Annotations
      • Jakarta Inject
      • Jakarta Servlet
      • Jakarta Faces (JSF)
      • Jakarta WebSocket
      • Jakarta REST (JAX-RS)
      • Jakarta MVC
      • Jakarta Persistence (JPA)
      • Jakarta Transactions (JTA)
      • Jakarta Data
      • Entity Lifecycle Callbacks
      • Advanced JPQL
      • Jakarta Security
      • Jakarta Authentication
      • Jakarta Authorization
      • Jakarta Messaging (JMS)
      • Jakarta Mail
    • Reactive Programming Introduction
    • Reactive Streams
    • Project Reactor
    • Mono and Flux
    • Reactor Operators
    • Spring WebFlux
    • WebFlux Router Functions
    • WebClient
    • R2DBC
    • RxJava
    • Backpressure
    • Schedulers
    • Reactive Error Handling
    • Testing Reactive Code
    • Docker vs VM
    • Kubernetes vs Docker Swarm
      • GitHub Actions
      • GitLab CI
      • Jenkins
      • Jenkins Pipeline
      • CircleCI
      • Azure DevOps
      • Docker Basics for Java
      • Java Dockerfile Best Practices
      • Docker Compose
      • Google Jib
      • Spring Boot Docker
      • Kubernetes Basics
      • ConfigMaps and Secrets
      • Health Checks
      • Helm Charts
      • Horizontal Pod Autoscaler
    • AWS vs Azure vs GCP
      • AWS SDK for Java v2
      • AWS Lambda
      • AWS S3
      • AWS SQS
      • DynamoDB
      • AWS ECS
      • AWS RDS
      • Azure SDK for Java
      • Azure Functions
      • Azure Blob Storage
      • Azure Service Bus
      • Google Cloud Java SDK
      • Cloud Run
      • Cloud Storage
      • Cloud Pub/Sub
    • Jackson vs Gson
      • Jackson
      • Gson
      • JSON-B
      • JSON-P
      • OkHttp
      • Apache HttpClient
      • Java HTTP Client
      • Retrofit
      • Apache Commons Lang
      • Apache Commons IO
      • Apache Commons Collections
      • Vavr
      • Joda-Time
      • MapStruct
      • ModelMapper
      • Dozer
      • Bean Validation (Jakarta)
      • Hibernate Validator
      • Custom Validators
    • SLF4J
    • Logback
    • Log4j2
    • Logging Best Practices
    • Micrometer
    • Prometheus Integration
    • Grafana Dashboards
    • OpenTelemetry
    • Spring Actuator Metrics
    • Mapped Diagnostic Context
    • Log Aggregation
    • Health Checks
    • SonarQube
    • Checkstyle
    • SpotBugs
    • PMD
    • Error Prone
    • Google Java Format
    • Refactoring Basics
    • Extract Method
    • Replace Conditional with Polymorphism
    • Code Review Best Practices
    • Managing Technical Debt
    • SOLID Principles
    • Clean Code in Java
    • Code Coverage
    • Mutation Testing
      • Lambda expressions
      • Stream API
      • Optional
      • Default methods
      • Method references
      • Date and Time API
      • Nashorn JavaScript
      • CompletableFuture
      • Parallel arrays
      • Module system (JPMS)
      • JShell
      • Private methods in interfaces
      • Collection factory methods
      • Try-with-resources improvements
      • Stream API additions
      • Process API updates
      • Local variable type inference (var)
      • Application Class-Data Sharing
      • Root certificates
      • Garbage collector interface
      • HTTP Client API
      • String methods (isBlank, lines, strip)
      • Files.readString/writeString
      • Nest-based access control
      • ZGC experimental
      • Removed Java EE modules
      • Switch expressions (preview)
      • String indent/transform
      • Shenandoah GC experimental
      • Microbenchmark suite (JMH) improvements
      • Text blocks (preview)
      • Switch expressions (preview 2)
      • Dynamic CDS archives
      • ZGC uncommit unused memory
      • Records (preview)
      • Pattern matching for instanceof (preview)
      • Helpful NullPointerExceptions
      • Switch expressions (standard)
      • Foreign Memory API (incubator)
      • Text blocks (standard)
      • Sealed classes (preview)
      • Hidden classes
      • Records (second preview)
      • ZGC production-ready
      • Records (standard)
      • Pattern matching for instanceof (standard)
      • Vector API (incubator)
      • Unix-domain socket channels
      • Stream.toList()
      • Sealed classes (standard)
      • Pattern matching for switch (preview)
      • Foreign Function & Memory API (incubator)
      • Deprecate Security Manager
      • Context-specific deserialization filters
      • Simple web server
      • Code snippets in JavaDoc
      • UTF-8 by default
      • Pattern matching for switch (preview 2)
      • Vector API (incubator 2)
      • Virtual threads (preview)
      • Structured concurrency (incubator)
      • Record patterns (preview)
      • Pattern matching for switch (preview 3)
      • Foreign API (preview)
      • Scoped values (incubator)
      • Record patterns (preview 2)
      • Virtual threads (preview 2)
      • Pattern matching for switch (preview 4)
      • Foreign API (preview 2)
      • Virtual threads (standard)
      • Sequenced collections
      • Record patterns (standard)
      • Pattern matching for switch (standard)
      • String templates (preview)
      • Generational ZGC
  • GitHub
  • Twitter / X
  • to navigate
  • to select
  • to close
    • Home
    • Interview Guide
    • Interview FAQ
    On this page

    Interview FAQ

    article

    How to prepare for Java interview?

    FAQ: How to prepare for Java interview?
    article

    System design interview tips?

    FAQ: System design interview tips?
    article

    Behavioral interview STAR method?

    FAQ: Behavioral interview STAR method?
    article

    How to explain projects?

    FAQ: How to explain projects?
    article

    Salary negotiation tips?

    FAQ: Salary negotiation tips?
    article

    Remote interview best practices?

    FAQ: Remote interview best practices?
    article

    Whiteboard vs laptop coding?

    FAQ: Whiteboard vs laptop coding?
    article

    How to handle unknown questions?

    FAQ: How to handle unknown questions?
    article

    Follow-up questions to ask?

    FAQ: Follow-up questions to ask?
    article

    Red flags in interviews?

    FAQ: Red flags in interviews?
    article

    Junior vs senior expectations?

    FAQ: Junior vs senior expectations?
    article

    How long to prepare?

    FAQ: How long to prepare?
    article

    Mock interview benefits?

    FAQ: Mock interview benefits?
    article

    Portfolio for backend dev?

    FAQ: Portfolio for backend dev?
    article

    Open source contribution value?

    FAQ: Open source contribution value?
    article

    Certification worth it?

    FAQ: Certification worth it?

    © 2026 Java Java Hub.