- AtomicInteger Example: Thread-Safe Counter
- Basic ExecutorService Example: Submitting Tasks
- Basic Thread Pool Example
- Creating Threads: Thread Class vs Runnable Interface
- Creating and Using a Cached Thread Pool Executor
- Creating and Using a Fixed Thread Pool Executor
- Daemon Thread Example: Auto-Saving Application
- Daemon Thread Example: Heartbeat Monitoring
- Deadlock Demonstration with Two Threads
- ForkJoinPool Example: Recursive Task for Summing Array Elements
- ReadWriteLock Example with Data Access
- ReentrantLock Example
- Scheduled Thread Pool Example
- ScheduledExecutorService Example: Delayed Task Execution
- ScheduledExecutorService Example: Periodic Task Execution
- Starvation Demonstration with Thread Priorities
- Synchronized Block for Thread Safety
- Synchronized Methods: Controlling Access to Shared Resources
- Thread Interruption and Joining
- Thread Lifecycle Demonstration
- Thread State Transitions Demonstration
- Using ReentrantLock for Thread Synchronization
- <code>instanceof</code> with Interfaces
- Assignment Operators in Java: A Comprehensive Guide
- Basic Arithmetic Operations in Java
- Basic For Loop Example
- Basic Method Declaration and Calling in Java
- Basic Switch-Case Example
- Basic Try-Catch Example
- Basic While Loop Example
- Bitwise Operators in Java: An Introduction
- Boolean Wrapper Class and Conditional Logic
- Break Statement Example: Searching an Array
- Checked vs. Unchecked Exceptions in Java
- Comparing Floating-Point Numbers with Epsilon
- Comparing Integers with Relational Operators
- Compound Assignment Operators
- Continue Statement Example: Skipping Odd Numbers
- Creating and Using Custom Exceptions in Java
- Declaring and Using Primitive Data Types in Java
- Do-While Loop Example: Input Validation
- Do-While Loop Example: Number Guessing Game
- Enhanced For-Loop (For-Each) Example: Iterating Through an Array of Strings
- Enhanced For-Loop (For-Each) Example: Summing Elements in an Integer Array
- Exception Chaining in Java
- Exception Handling with Finally Block: Ensuring Resource Cleanup
- Explicit Type Casting (Narrowing Conversion) Example
- Factorial Calculation using Recursion
- Fibonacci Sequence using Recursion
- For-Each Loop (Enhanced For Loop)
- If-Else If-Else: Grading System Example
- Implicit Type Conversion (Widening Conversion) Example
- Labeled Break Example
- Labeled Continue Example
- Lambda Expression for Collection Processing
- Lambda Expression for Functional Interface Implementation
- Logical AND (&&) and Logical OR (||) in Java
- Method Overloading Example
- Method Overloading Example: Area Calculation
- Method Reference: Constructor Reference
- Method Reference: Converting Strings to Uppercase
- Multi-catch Exception Handling in Java
- Object Creation and Reference Assignment
- Operator Precedence and Associativity Demonstration
- Simple If-Else Example: Determining Even or Odd
- String Manipulation and Array Access in Java
- Summing Numbers with Varargs
- Switch-Case with Enums
- Ternary Operator: Assigning a Grade Based on Score
- Ternary Operator: Finding the Maximum of Two Numbers
- Throw vs Throws: Custom Exception Handling
- Try-Catch with Multiple Catch Blocks and Finally
- Type Conversion and Casting in Java
- Understanding Pass-by-Value in Java Methods
- Using <code>instanceof</code> to Check Object Type
- While Loop with Break Statement
- Wrapper Class Demonstration: Integer and Double
- Abstract Factory Pattern Example: GUI Factory
- Adapter Pattern Example: Converting Celsius to Fahrenheit
- Command Pattern Example: Remote Control
- Composite Pattern: Building Hierarchical Structures
- Decorator Pattern: Coffee Example
- External Iterator Example
- Facade Pattern Example: Order Processing System
- Factory Method Pattern: Creating Objects with Flexibility
- Implementing the Builder Pattern for a Computer
- Iterator Pattern Demonstration in Java
- Observer Pattern Implementation in Java
- Prototype Pattern: Cloning a Complex Object
- Proxy Pattern Demonstration in Java
- Singleton Pattern Implementation in Java
- State Pattern Example: Document State Management
- Strategy Pattern: Dynamic Sorting
- Strategy Pattern: File Compression
- Basic Lambda Expression in Java
- Calculating Average Salary by Department using Collectors.averagingInt and groupingBy
- Calculating the Sum of Even Numbers Using Stream Pipelines
- Chaining Optionals in Java 8
- Creating Optional Objects in Java
- Creating Streams in Java 8: Stream.of() and Arrays.stream()
- Custom Functional Interface and Lambda Expression Example
- Filtering and Processing Optional Elements in Streams
- Grouping Employees by Department using Collectors.groupingBy
- Grouping and Counting Words in a String Using Stream Pipelines
- Lambda Expression Scope Demonstration: Accessing Variables
- Lambda Expression with Multiple Parameters and Block Body
- Lambda Expressions with Built-in Functional Interfaces: Example 1 - Predicate
- Lambda Expressions with Built-in Functional Interfaces: Example 2 - Function
- Parallel Stream Example: Filtering and Collecting Data
- Parallel Stream Example: Summing a List of Numbers
- Using Optional Methods for Safe and Concise Code
- Using Optional with Streams to Find the Maximum Value
- Adding Dependencies in Maven
- Applying a Gradle Plugin
- Basic Gradle Build Script
- Creating a Basic Gradle Project
- Creating a Basic Maven Project with the Maven Archetype Plugin
- Creating a JAR File with Gradle
- Custom Gradle Task
- Gradle Dependency Management: Basic Example
- Gradle Dependency Management: Using Versions from Properties
- Maven Project Structure Example
- POM File with Multiple Dependencies and Plugins
- Simple Maven POM File
- Transitive Dependencies in Maven
- Using the Maven Assembly Plugin
- Using the Maven Compiler Plugin
- ArrayDeque Example: Adding and Removing Elements
- ArrayDeque as a Stack: Implementing Undo/Redo
- ArrayList vs LinkedList: Basic Operations
- BlockingQueue Example with Producer-Consumer
- Collecting Names into a Comma-Separated String
- ConcurrentHashMap Example
- ConcurrentLinkedQueue Example
- ConcurrentSkipListSet Example
- Filtering and Mapping Objects with Streams
- Filtering and Mapping a List of Integers
- Grouping Students by Grade Level
- HashMap vs TreeMap: Choosing the Right Map Implementation
- HashSet vs TreeSet: A Comparison
- LinkedHashMap Example: Maintaining Insertion Order
- NavigableMap and SortedMap Example
- PriorityQueue Example: Managing Tasks by Priority
- PriorityQueue with Custom Comparator: Ordering Strings by Length
- Sorting a List of Objects Using Comparator
- Stream API: Filtering and Mapping a List
- Stream API: Finding the Maximum Value
- Using Iterator and ListIterator in Java
- Asynchronous File Channel Example
- Asynchronous File Channel with CompletionHandler
- Asynchronous File Channel with Future
- Basic Path Operations with Java NIO
- Custom Serialization in Java
- Custom Serialization with Externalizable Interface
- File Locking with FileChannel in Java
- Reading a Text File with NIO Buffers and Channels
- Reading and Writing Files with FileReader and FileWriter in Java
- Reading and Writing Text Files Using Path and Files API
- Reading and Writing Text Files with BufferedReader and BufferedWriter
- Serialization and Deserialization with Object Streams
- Serialization and Deserialization with Serializable Interface
- Walking a File Tree with FileVisitOption in Java NIO
- HTTP POST Request with JSON payload using HttpURLConnection
- Java HTTP Client Example: REST API Consumption
- Java SOAP Client Example
- Java TCP Socket Example
- Java UDP Socket Example
- Object Serialization and Deserialization Over Sockets
- Simple HTTP GET Request using HttpURLConnection
- Simple JAX-RS REST Service
- Simple RESTful Web Service with Spring Boot
- Simple Server-Client Socket Communication in Java
- Simple Socket Communication with Input and Output Streams
- AES Encryption and Decryption Example
- AES Encryption and Decryption using JCE
- Digital Signature Generation and Verification with RSA
- HMAC-SHA256 Message Authentication Code Generation and Verification
- JAAS Authentication Example with a Simple Login Module
- Mutual Authentication with SSL/TLS in Java
- OAuth 2.0 Authentication Flow with JWT
- RBAC with Spring Security Annotations
- Simple RBAC Implementation in Java
- Demonstrating Mark and Sweep Garbage Collection
- Finalization Example with Resource Cleanup
- Garbage Collection Tuning Example: Setting Heap Size
- Generational Garbage Collection Demonstration
- Heap Memory and String Interning
- Heap and Stack Memory Demonstration and Profiling
- Recursive Factorial Calculation and Stack Memory Usage
- Resource Leak with Unclosed Stream
- Simple Memory Leak Example with Static List
- Simple Object Allocation in the Heap
- Simulating Generational Garbage Collection
- Understanding GC Roots and Reachability
- Using WeakReferences to Prevent Memory Leaks
- Abstract Class Example: Data Access Object (DAO)
- Abstract Class Example: Shape Hierarchy
- Anonymous Inner Class Example: Implementing a Listener
- Another Example: `Employee` Class with Encapsulation
- Basic Class Structure in Java
- Basic Constructor Example: The `Dog` Class
- Constructor Chaining in a Multi-Level Inheritance Hierarchy
- Constructor Overloading in Java: Employee Class Example
- Creating and Using a Simple `Dog` Class
- Default Methods in Interfaces: A Concrete Example
- Demonstrating Constructor Chaining with Inheritance
- Dynamic Binding in Polymorphism
- Encapsulation Example: Bank Account
- Encapsulation Example: Employee Data
- Encapsulation with Access Modifiers in Java
- Encapsulation with Getters and Setters in Java
- Encapsulation with Private Fields and Public Getters/Setters in Java
- Final Keyword: Preventing Inheritance and Modification
- Illustrating Inheritance, Super, and This Keywords in Java
- Inheritance Example: Animal and Dog
- Interface-Based Shape Calculation
- Local Inner Class Example: Validating Data
- Method Overloading vs. Method Overriding in Java
- Method Overriding Example: Animal and Dog
- Multiple Inheritance via Interfaces in Java
- Non-Static Inner Class Example: Car and Engine
- Object Creation with Different Constructors
- Polymorphism with Abstract Classes and Dynamic Binding
- Polymorphism with Abstract Classes and Interfaces: Shape Example
- Service Interface and Implementation
- Static Inner Class Example: Accessing Outer Class Members
- Static Method for Utility Class: String Reversal
- Static Variable and Method Example: Employee ID Generator
- Static vs. Dynamic Polymorphism in Java
- Understanding Object References in Java
- Upcasting and Downcasting in Java Polymorphism
- Using 'this' to Call Another Constructor (Constructor Chaining)
- Using 'this' to Differentiate Instance Variables from Local Variables
- Annotation-Based Spring IoC Configuration
- Around Advice with Spring AOP: Method Performance Monitoring
- Basic Spring IoC Container Example
- Conditional Bean Creation with Auto-Configuration
- Constructor Injection in Spring
- Creating a Simple Spring Boot Application
- Creating a Spring Boot Application with Command Line Runner
- Custom Auto-Configuration for Greeting Service
- Declarative Transaction Management with Spring Data JPA
- Defining a MongoDB Repository with Spring Data
- Defining and Using Beans in Spring
- Exposing a JPA Repository as a REST Endpoint with Spring Data REST
- Handling Rollback Scenarios in Spring Data JPA
- Setter Injection in Spring
- Simple Spring AOP Example: Logging Aspect
- Spring Boot Actuator: Custom Info Endpoint
- Spring Boot Actuator: Exposing Health Endpoint
- Spring Data JPA: Custom Query with @Query
- Spring Data JPA: Simple Repository Example
- Using Spring Boot Starter Data JPA for Database Access
- Using Spring Boot Starter Web for REST API Development
- Asserting Exceptions with JUnit
- Basic JUnit 5 Test Example
- Basic JUnit Assertions Example
- Integration Testing with Testcontainers: PostgreSQL Example
- Integration Testing with Testcontainers: Redis Example
- Integration Testing with an In-Memory Database
- Mockito: Argument Captor Example
- Parameterized Tests in JUnit 5
- Parameterized Unit Testing with JUnit 5
- Refactoring in TDD: Extract Method
- Refactoring in TDD: Rename Method
- Simple Calculator with TDD
- Spring Boot Integration Test with MockMvc
- Spring Boot Integration Test with TestRestTemplate
- TDD Example: Simple Calculator
- TDD Example: String Reverser
- Unit Testing with Mockito: Basic Example