• 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
    • Distributed Systems
    • Advanced Distributed Systems
    • Storage
    On this page

    Storage

    article

    Consistent Hashing Ring

    Guide to consistent hashing ring for Java developers.
    article

    Data Partitioning Strategies

    Guide to data partitioning strategies for Java developers.
    article

    Hot Partition Problem

    Guide to hot partition problem for Java developers.
    article

    Read Repair

    Guide to read repair for Java developers.
    article

    Hinted Handoff

    Guide to hinted handoff for Java developers.
    article

    Anti-Entropy Repair

    Guide to anti-entropy repair for Java developers.
    article

    Multi-Region Replication

    Guide to multi-region replication for Java developers.
    article

    Conflict Resolution Strategies

    Guide to conflict resolution strategies for Java developers.

    © 2026 Java Java Hub.