Skip to main content
Mapagam

54 SECTIONS · 787 TOPICS

Core Java Roadmap

  1. Working with Primitive Data Types

    1. 1. Declaring Integer Types
    2. Example: Integer literals
    3. 2. Working with Floating-Point Types
    4. Example: Float vs double
    5. 3. Using Character Type
    6. 4. Understanding Boolean Type
    7. 5. Understanding Default Values
    8. 6. Working with Literals
    9. 7. Understanding Type Casting
    10. 8. Using Wrapper Classes
    11. 9. Understanding Autoboxing and Unboxing
    12. 10. Comparing Primitives vs Wrapper Classes

  2. Working with Variables and Scoping

    1. 1. Declaring Variables
    2. 2. Understanding Variable Scope
    3. 3. Understanding Type Inference
    4. 4. Working with Constants
    5. Example: Constants
    6. 5. Understanding Variable Shadowing
    7. 6. Using Static Variables
    8. Example: Static counter
    9. 7. Using Instance Variables
    10. 8. Understanding Variable Initialization
    11. 9. Working with System Properties
    12. 10. Working with Environment Variables

  3. Working with Operators and Expressions

    1. 1. Using Arithmetic Operators (+, -, *, /, %)
    2. 2. Using Unary Operators (++, --, +, -, !)
    3. 3. Using Relational Operators (==, !=, >, <, >=, <=)
    4. 4. Using Logical Operators (&&, ||, !)
    5. 5. Using Bitwise Operators (&, |, ^, ~, <<, >>, >>>)
    6. 6. Using Assignment Operators (=, +=, -=, *=, /=)
    7. 7. Using Ternary Operator (? :)
    8. Example: Ternary
    9. 8. Understanding Operator Precedence
    10. 9. Using instanceof Operator
    11. Example: Pattern matching for instanceof
    12. 10. Understanding Short-Circuit Evaluation
    13. Example: Null-safe check

  4. Working with Control Flow Statements

    1. 1. Using if-else Statements
    2. 2. Using Nested if Statements
    3. Example: Nested if
    4. 3. Using switch Statement (traditional)
    5. Example: Traditional switch
    6. 4. Using Switch Expressions
    7. Example: Switch expression with arrow
    8. 5. Understanding Pattern Matching in switch
    9. Example: Type and record patterns
    10. 6. Using for Loop
    11. 7. Using while Loop
    12. Example: while
    13. 8. Using do-while Loop
    14. Example: do-while
    15. 9. Using break Statement
    16. Example: Labeled break
    17. 10. Using continue Statement
    18. 11. Using return Statement
    19. 12. Using assert Statement

  5. Working with Arrays

    1. 1. Declaring and Creating Arrays
    2. 2. Initializing Arrays
    3. Example: Initialization
    4. 3. Accessing Array Elements
    5. 4. Working with Multidimensional Arrays
    6. Example: 2D and jagged
    7. 5. Understanding Array Length
    8. 6. Iterating Arrays
    9. Example: Iteration patterns
    10. 7. Copying Arrays
    11. 8. Sorting Arrays
    12. 9. Searching Arrays
    13. 10. Comparing Arrays
    14. 11. Converting Arrays
    15. 12. Working with Varargs (...args)
    16. Example: Varargs method

  6. Working with Strings

    1. 1. Creating Strings
    2. 2. Understanding String Immutability
    3. 3. Understanding String Pool
    4. 4. Concatenating Strings
    5. 5. Comparing Strings
    6. 6. Extracting Substrings
    7. 7. Searching Strings
    8. 8. Modifying Strings
    9. 9. Splitting Strings
    10. 10. Formatting Strings
    11. 11. Converting Cases
    12. 12. Using StringBuilder
    13. Example: StringBuilder
    14. 13. Using StringBuffer
    15. 14. Working with Text Blocks
    16. Example: Text block

  7. Working with Modern String Features

    1. 1. Using Text Blocks
    2. 2. Understanding Text Block Indentation
    3. Example: Indentation handling
    4. 3. Using Text Block Escape Sequences (\, \s, \n)
    5. 4. Using Text Block with formatted()
    6. Example: formatted
    7. 5. Using String.indent() Method
    8. 6. Using String.transform() Method
    9. Example: transform
    10. 7. Using String.isBlank() Method
    11. 8. Using String.lines() Method
    12. Example: Stream of lines
    13. 9. Using String.repeat() Method
    14. 10. Understanding String Templates

  8. Working with Math and Random Numbers

    1. 1. Using Math Class Methods
    2. 2. Working with Trigonometric Functions
    3. 3. Using Exponential Functions
    4. 4. Rounding Numbers
    5. 5. Generating Random Numbers
    6. 6. Using Random Class
    7. Example: Random
    8. 7. Using SecureRandom
    9. 8. Understanding Random Number Seeds
    10. 9. Working with BigInteger
    11. Example: BigInteger
    12. 10. Working with BigDecimal
    13. Example: Money math

  9. Working with Classes and Objects

    1. 1. Defining Classes
    2. Example: Class declaration
    3. 2. Creating Objects
    4. 3. Declaring Instance Variables
    5. 4. Defining Methods
    6. Example: Method signatures
    7. 5. Using this Keyword
    8. 6. Overloading Methods
    9. 7. Overloading Constructors
    10. Example: Constructor chaining
    11. 8. Understanding Static Members
    12. 9. Using Static Blocks
    13. Example: Static initializer
    14. 10. Working with Instance Initializer Blocks
    15. 11. Understanding Object Class Methods
    16. 12. Implementing equals() and hashCode()
    17. Example: equals + hashCode
    18. 13. Understanding Clone Method

  10. Understanding Encapsulation and Access Modifiers

    1. 1. Using Access Modifiers
    2. 2. Creating Getter Methods
    3. Example: Getters
    4. 3. Creating Setter Methods
    5. 4. Understanding Package-Private Access
    6. 5. Designing Immutable Classes
    7. 6. Understanding Information Hiding
    8. 7. Using JavaBeans Conventions
    9. 8. Working with Record Classes
    10. Example: Record
    11. 9. Understanding Record Components
    12. 10. Comparing Records vs Traditional Classes

  11. Understanding Inheritance

    1. 1. Creating Subclasses
    2. Example: extends
    3. 2. Using super Keyword
    4. 3. Overriding Methods
    5. 4. Understanding Method Overriding Rules
    6. 5. Calling Parent Constructors (super())
    7. 6. Understanding Constructor Chaining
    8. Constructor chain
    9. 7. Using final Keyword
    10. 8. Understanding Object as Root Class
    11. 9. Working with instanceof and Type Checking
    12. Example: Pattern matching
    13. 10. Understanding Covariant Return Types
    14. Example: Covariant return
    15. 11. Understanding Method Overloading vs Overriding

  12. Understanding Polymorphism

    1. 1. Understanding Compile-Time Polymorphism
    2. 2. Understanding Runtime Polymorphism
    3. Example: Dynamic dispatch
    4. 3. Using Upcasting
    5. 4. Using Downcasting
    6. 5. Understanding Dynamic Method Dispatch
    7. 6. Working with Virtual Methods
    8. 7. Understanding Type Erasure in Generics
    9. 8. Using Polymorphic Collections
    10. Example: Polymorphic list
    11. 9. Understanding Late Binding

  13. Working with Abstract Classes and Interfaces

    1. 1. Defining Abstract Classes
    2. Example: Abstract class
    3. 2. Creating Abstract Methods
    4. 3. Implementing Abstract Classes
    5. 4. Defining Interfaces
    6. Example: Interface
    7. 5. Implementing Interfaces
    8. 6. Using Multiple Inheritance with Interfaces
    9. Example: Diamond resolution
    10. 7. Defining Default Methods
    11. 8. Defining Static Methods in Interfaces
    12. 9. Defining Private Methods in Interfaces
    13. 10. Understanding Functional Interfaces
    14. Example: Custom @FunctionalInterface
    15. 11. Working with Marker Interfaces
    16. 12. Understanding Interface vs Abstract Class

  14. Working with Sealed Classes (Java 17+)

    1. 1. Declaring Sealed Classes
    2. Example: Sealed hierarchy
    3. 2. Using permits Clause
    4. 3. Creating Permitted Subclasses
    5. 4. Understanding Sealed Interfaces
    6. Example: Sealed interface
    7. 5. Combining Sealed Classes with Pattern Matching
    8. Example: Exhaustive switch
    9. 6. Understanding Exhaustiveness Checking
    10. 7. Using Sealed Classes for Domain Modeling
    11. 8. Comparing Sealed Classes vs Final Classes

  15. Working with Pattern Matching

    1. 1. Using Pattern Matching for instanceof
    2. Example: Auto-cast pattern
    3. 2. Understanding Type Patterns
    4. 3. Using Pattern Matching in switch
    5. Example: Switch with patterns
    6. 4. Using Guarded Patterns
    7. Example: when clause
    8. 5. Understanding Record Patterns
    9. Example: Record pattern
    10. 6. Deconstructing Records with Patterns
    11. 7. Using Nested Record Patterns
    12. Example: Nested deconstruction
    13. 8. Understanding Pattern Matching Exhaustiveness
    14. 9. Combining Patterns with Sealed Classes
    15. 10. Using Unnamed Patterns
    16. Example: Underscore for unused

  16. Working with Nested and Inner Classes

    1. 1. Defining Static Nested Classes
    2. Example: Static nested
    3. 2. Defining Non-Static Inner Classes
    4. 3. Creating Local Classes
    5. Example: Local class
    6. 4. Creating Anonymous Classes
    7. Example: Anonymous class
    8. 5. Accessing Outer Class Members
    9. 6. Understanding .this Syntax
    10. Example: Outer.this
    11. 7. Using Inner Classes for Callbacks
    12. 8. Converting Anonymous to Lambda
    13. 9. Understanding Nested Class Use Cases

  17. Working with Enumerations

    1. 1. Defining Enums
    2. Example: Basic enum
    3. 2. Adding Fields to Enums
    4. Example: Enum with fields
    5. 3. Adding Methods to Enums
    6. 4. Adding Constructors to Enums
    7. 5. Using values() Method
    8. 6. Using valueOf() Method
    9. 7. Using ordinal() Method
    10. 8. Implementing Interfaces in Enums
    11. Example: Enum implements interface
    12. 9. Using EnumSet Collections
    13. Example: EnumSet
    14. 10. Using EnumMap Collections
    15. 11. Comparing Enums
    16. 12. Understanding Enum Singleton Pattern
    17. Example: Enum singleton

  18. Working with Packages and Imports

    1. 1. Creating Packages
    2. 2. Understanding Package Naming Conventions
    3. 3. Importing Classes
    4. 4. Using Wildcard Imports (import java.util.*)
    5. 5. Importing Static Members (import static)
    6. Example: Static import
    7. 6. Understanding Default Package
    8. 7. Resolving Package Conflicts
    9. Example: Conflict resolution
    10. 8. Organizing Code with Packages
    11. 9. Understanding CLASSPATH
    12. 10. Compiling Packages
    13. Example: javac with packages

  19. Understanding Exception Handling

    1. 1. Understanding Exception Hierarchy
    2. Exception hierarchy
    3. 2. Using try-catch Blocks
    4. Example: try-catch
    5. 3. Catching Multiple Exceptions
    6. Example: Multi-catch
    7. 4. Using finally Block
    8. 5. Using try-with-resources
    9. Example: Auto-close
    10. 6. Throwing Exceptions
    11. 7. Declaring Exceptions
    12. 8. Creating Custom Exceptions
    13. Example: Custom exception
    14. 9. Understanding Checked vs Unchecked Exceptions
    15. 10. Rethrowing Exceptions
    16. Example: Wrap and rethrow
    17. 11. Understanding Suppressed Exceptions
    18. 12. Using Exception Chaining
    19. 13. Understanding Best Practices

  20. Working with Generics

    1. 1. Creating Generic Classes
    2. Example: Generic class
    3. 2. Creating Generic Methods
    4. Example: Generic method
    5. 3. Using Bounded Type Parameters
    6. 4. Understanding Wildcards (?, extends, super)
    7. 5. Using Upper Bounded Wildcards (? extends T)
    8. Example: Producer of T
    9. 6. Using Lower Bounded Wildcards (? super T)
    10. Example: Consumer of T
    11. 7. Understanding Unbounded Wildcards (?)
    12. 8. Understanding Type Erasure
    13. 9. Working with Generic Arrays Limitations
    14. 10. Using Multiple Type Parameters
    15. Example: Pair
    16. 11. Understanding PECS Principle (Producer Extends Consumer Super)
    17. 12. Understanding Generic Method Inference

  21. Working with Collections Framework

    1. 1. Understanding Collection Interface Hierarchy
    2. Collection hierarchy
    3. 2. Using ArrayList
    4. 3. Using LinkedList
    5. 4. Using Vector
    6. 5. Using Stack
    7. 6. Choosing List Implementation
    8. 7. Using HashSet
    9. 8. Using LinkedHashSet
    10. 9. Using TreeSet
    11. 10. Using HashMap
    12. Example: HashMap operations
    13. 11. Using LinkedHashMap
    14. 12. Using TreeMap
    15. 13. Using Hashtable
    16. 14. Understanding IdentityHashMap

  22. Working with Sequenced Collections (Java 21+)

    1. 1. Understanding SequencedCollection Interface
    2. 2. Using addFirst() and addLast() Methods
    3. Example: SequencedCollection ops
    4. 3. Using getFirst() and getLast() Methods
    5. 4. Using removeFirst() and removeLast() Methods
    6. 5. Using reversed() Method
    7. 6. Understanding SequencedSet Interface
    8. 7. Understanding SequencedMap Interface
    9. 8. Using firstEntry() and lastEntry() Methods
    10. Example: SequencedMap
    11. 9. Using pollFirstEntry() and pollLastEntry() Methods
    12. 10. Converting Legacy Collections to Sequenced

  23. Working with Queue and Deque

    1. 1. Understanding Queue Interface
    2. 2. Using PriorityQueue
    3. Example: Priority queue
    4. 3. Using ArrayDeque
    5. 4. Using LinkedList as Queue
    6. 5. Using offer(), poll(), peek() Methods
    7. 6. Understanding Deque Interface
    8. 7. Using addFirst(), addLast() Methods
    9. 8. Using removeFirst(), removeLast() Methods
    10. 9. Using Deque as Stack
    11. 10. Using Deque as Queue

  24. Working with Collection Utilities

    1. 1. Sorting Collections
    2. Example: Sort with comparator
    3. 2. Searching Collections
    4. 3. Reversing Collections
    5. 4. Shuffling Collections
    6. 5. Creating Unmodifiable Collections
    7. 6. Creating Synchronized Collections
    8. 7. Finding Min and Max
    9. 8. Replacing Elements
    10. 9. Copying Collections
    11. 10. Creating Singleton Collections
    12. 11. Using Frequency Method
    13. 12. Using Disjoint Method

  25. Working with Iterators and Comparators

    1. 1. Using Iterator Interface
    2. 2. Using ListIterator
    3. 3. Using Enhanced for Loop
    4. 4. Using forEach() Method
    5. Example: forEach
    6. 5. Implementing Comparable Interface
    7. Example: Comparable
    8. 6. Implementing Comparator Interface
    9. 7. Creating Comparator with Lambda
    10. Example: Lambda comparator
    11. 8. Chaining Comparators
    12. 9. Reversing Comparators
    13. 10. Using Comparator Factory Methods
    14. 11. Understanding Natural Ordering vs Custom Ordering

  26. Working with Lambda Expressions

    1. 1. Understanding Lambda Syntax
    2. 2. Creating Single-Parameter Lambdas
    3. 3. Creating Multi-Parameter Lambdas
    4. Example: Multi-param
    5. 4. Using Block Lambdas
    6. 5. Understanding Effectively Final Variables
    7. 6. Using Method References (Class::method)
    8. 7. Using Constructor References (Class::new)
    9. Example: Constructor reference
    10. 8. Understanding Target Typing
    11. 9. Using Lambda with Collections
    12. 10. Replacing Anonymous Classes with Lambdas
    13. 11. Understanding Lambda Variable Scope

  27. Working with Functional Interfaces

    1. 1. Using Predicate<T>
    2. 2. Using Function<T,R>
    3. Example: Function composition
    4. 3. Using Consumer<T>
    5. 4. Using Supplier<T>
    6. 5. Using UnaryOperator<T>
    7. 6. Using BinaryOperator<T>
    8. 7. Using BiPredicate<T,U>
    9. 8. Using BiFunction<T,U,R>
    10. 9. Using BiConsumer<T,U>
    11. 10. Creating Custom Functional Interfaces
    12. Example: Custom interface
    13. 11. Combining Predicates
    14. Example: Predicate composition
    15. 12. Composing Functions

  28. Working with Stream API

    1. 1. Creating Streams
    2. 2. Using Intermediate Operations
    3. 3. Using Terminal Operations
    4. 4. Filtering Elements
    5. Example: Filter
    6. 5. Mapping Elements
    7. 6. Flattening Streams
    8. Example: flatMap
    9. 7. Sorting Streams
    10. 8. Removing Duplicates
    11. 9. Limiting Streams
    12. 10. Peeking Elements
    13. 11. Checking Conditions
    14. 12. Finding Elements
    15. 13. Understanding Parallel Streams

  29. Working with Modern Stream Features

    1. 1. Using Stream.toList() Method
    2. 2. Using Stream.mapMulti() Method
    3. Example: mapMulti
    4. 3. Using Stream.teeing() Collector
    5. Example: teeing
    6. 4. Using Gatherers API
    7. 5. Creating Custom Gatherers
    8. Example: Custom gatherer
    9. 6. Using windowFixed() Gatherer
    10. Example: Fixed window
    11. 7. Using windowSliding() Gatherer
    12. 8. Using fold() Gatherer
    13. 9. Using scan() Gatherer
    14. 10. Composing Gatherers

  30. Working with Stream Collectors

    1. 1. Collecting to List
    2. 2. Collecting to Set
    3. 3. Collecting to Map
    4. Example: toMap
    5. 4. Joining Strings
    6. 5. Grouping Elements
    7. Example: groupingBy
    8. 6. Partitioning Elements
    9. 7. Counting Elements
    10. 8. Finding Statistics
    11. 9. Reducing Elements
    12. Example: reduce
    13. 10. Creating Custom Collectors
    14. 11. Collecting to Unmodifiable Collections
    15. 12. Using Downstream Collectors
    16. Example: Downstream chaining

  31. Working with Optional

    1. 1. Creating Optional
    2. 2. Checking Presence
    3. 3. Getting Values
    4. 4. Throwing Exceptions
    5. Example: orElseThrow
    6. 5. Mapping Values
    7. 6. Filtering Values
    8. Example: filter
    9. 7. Consuming Values
    10. 8. Chaining Operations
    11. 9. Converting to Stream
    12. 10. Understanding Optional Best Practices
    13. 11. Avoiding Optional Misuse

  32. Working with Date and Time API

    1. 1. Using LocalDate
    2. Example: LocalDate
    3. 2. Using LocalTime
    4. 3. Using LocalDateTime
    5. 4. Using ZonedDateTime
    6. Example: ZonedDateTime
    7. 5. Using Instant
    8. 6. Using Duration
    9. 7. Using Period
    10. 8. Formatting Dates
    11. Example: Format/parse
    12. 9. Parsing Dates
    13. 10. Manipulating Dates
    14. 11. Comparing Dates
    15. 12. Working with Time Zones
    16. 13. Understanding Clock Class

  33. Working with Internationalization and Localization

    1. 1. Understanding Locale Class
    2. 2. Creating Locales
    3. 3. Using ResourceBundle
    4. Example: Resource bundle
    5. 4. Loading Resource Bundles
    6. 5. Formatting Numbers
    7. 6. Formatting Currencies
    8. Example: Currency
    9. 7. Formatting Dates
    10. 8. Using MessageFormat
    11. 9. Understanding Default Locale
    12. 10. Supporting Multiple Languages

  34. Working with File I/O (NIO.2)

    1. 1. Working with Path Interface
    2. 2. Working with Files Class
    3. 3. Reading Files
    4. Example: Read patterns
    5. 4. Writing Files
    6. 5. Copying Files
    7. 6. Moving Files
    8. 7. Deleting Files
    9. 8. Checking File Existence
    10. 9. Creating Directories
    11. 10. Listing Directory Contents
    12. Example: Walk file tree
    13. 11. Using BufferedReader and BufferedWriter
    14. 12. Working with File Attributes
    15. 13. Using try-with-resources for I/O
    16. 14. Watching Directories
    17. Example: WatchService

  35. Working with Serialization

    1. 1. Implementing Serializable Interface
    2. Example: Serializable
    3. 2. Using ObjectOutputStream
    4. 3. Using ObjectInputStream
    5. Example: Read object
    6. 4. Understanding serialVersionUID
    7. 5. Using transient Keyword
    8. 6. Customizing Serialization
    9. Example: Custom serialization
    10. 7. Implementing Externalizable Interface
    11. 8. Understanding Serialization Security Concerns
    12. 9. Handling Versioning Issues
    13. 10. Using Serialization Proxy Pattern

  36. Working with Regular Expressions

    1. 1. Understanding Pattern Class
    2. 2. Understanding Matcher Class
    3. 3. Using Character Classes ([abc], [^abc], [a-z])
    4. 4. Using Predefined Classes (\d, \w, \s)
    5. 5. Using Quantifiers (*, +, ?, {n}, {n,m})
    6. 6. Using Anchors (^, $, \b, \B)
    7. 7. Using Grouping and Capturing
    8. Example: Named groups
    9. 8. Using Alternation (|)
    10. 9. Replacing Text
    11. 10. Splitting Text
    12. 11. Using Flags
    13. 12. Understanding Greedy vs Reluctant vs Possessive

  37. Working with Networking

    1. 1. Using URL and URI Classes
    2. 2. Making HTTP Requests with HttpClient
    3. Example: Sync GET
    4. 3. Sending GET Requests
    5. 4. Sending POST Requests
    6. Example: POST JSON
    7. 5. Handling HTTP Responses
    8. 6. Making Async HTTP Requests
    9. Example: Async
    10. 7. Setting Request Headers
    11. 8. Working with Sockets
    12. 9. Implementing TCP Client/Server
    13. Example: Echo server
    14. 10. Implementing UDP Communication
    15. 11. Handling Network Errors
    16. 12. Setting Timeouts
    17. 13. Working with WebSockets
    18. Example: WebSocket client

  38. Working with JDBC

    1. 1. Loading JDBC Drivers
    2. 2. Establishing Connections
    3. Example: Connection
    4. 3. Using Statement
    5. 4. Using PreparedStatement
    6. Example: PreparedStatement
    7. 5. Using CallableStatement
    8. 6. Working with ResultSet
    9. 7. Handling Transactions
    10. 8. Using Batch Processing
    11. Example: Batch insert
    12. 9. Handling SQL Exceptions
    13. 10. Using Connection Pools
    14. 11. Closing Resources Properly
    15. 12. Working with Database Metadata

  39. Working with Annotations

    1. 1. Understanding Built-in Annotations
    2. 2. Using @Override
    3. 3. Using @Deprecated
    4. Example: Deprecation
    5. 4. Using @SuppressWarnings
    6. 5. Using @FunctionalInterface
    7. 6. Creating Custom Annotations
    8. Example: Custom annotation
    9. 7. Using @Target
    10. 8. Using @Retention
    11. 9. Using @Documented
    12. 10. Using @Inherited
    13. 11. Using @Repeatable
    14. Example: Repeatable
    15. 12. Processing Annotations at Runtime
    16. Example: Reflection
    17. 13. Using Annotation Processors

  40. Working with Reflection

    1. 1. Getting Class Objects
    2. 2. Inspecting Class Information
    3. 3. Working with Fields
    4. Example: Field access
    5. 4. Working with Methods
    6. 5. Working with Constructors
    7. 6. Creating Instances Dynamically
    8. 7. Invoking Methods Dynamically
    9. 8. Accessing Private Members
    10. 9. Working with Generic Types
    11. 10. Using Class.forName()
    12. 11. Using ClassLoader
    13. 12. Understanding Reflection Performance
    14. 13. Using MethodHandles API
    15. Example: MethodHandle

  41. Working with Modules (JPMS) JAVA 9+

    1. 1. Understanding Module System
    2. 2. Creating Module Declarations (module-info.java)
    3. Example: module-info
    4. 3. Using requires Directive
    5. 4. Using exports Directive
    6. 5. Using opens Directive
    7. 6. Using provides and uses Directives
    8. 7. Understanding Service Loading
    9. Example: ServiceLoader
    10. 8. Compiling Modular Applications
    11. 9. Running Modular Applications
    12. 10. Working with Automatic Modules
    13. 11. Understanding Unnamed Module
    14. 12. Migrating to Modules
    15. 13. Using jlink Tool
    16. Example: jlink

  42. Working with Multithreading

    1. 1. Creating Threads
    2. Example: Thread creation
    3. 2. Implementing Runnable Interface
    4. 3. Implementing Callable Interface
    5. 4. Understanding Thread Lifecycle
    6. 5. Using Thread Methods (start, sleep, join)
    7. 6. Setting Thread Priority
    8. 7. Creating Daemon Threads
    9. 8. Interrupting Threads
    10. 9. Handling InterruptedException
    11. Example: Handle interruption
    12. 10. Setting Thread Names
    13. 11. Using ThreadGroup
    14. 12. Understanding Thread Safety
    15. 13. Identifying Race Conditions

  43. Working with Synchronization

    1. 1. Using synchronized Keyword
    2. Example: synchronized
    3. 2. Synchronizing Methods
    4. 3. Synchronizing Blocks
    5. 4. Understanding Intrinsic Locks (Monitor)
    6. 5. Using Lock Interface
    7. Example: Lock
    8. 6. Using ReentrantLock
    9. 7. Using ReadWriteLock
    10. 8. Using StampedLock
    11. Example: Optimistic read
    12. 9. Using volatile Keyword
    13. 10. Understanding Atomic Operations
    14. 11. Using Atomic Classes
    15. Example: Atomic counter
    16. 12. Avoiding Deadlocks
    17. 13. Understanding Memory Model (JMM)

  44. Working with Concurrent Collections

    1. 1. Using ConcurrentHashMap
    2. Example: ConcurrentHashMap
    3. 2. Using ConcurrentLinkedQueue
    4. 3. Using BlockingQueue
    5. 4. Using ArrayBlockingQueue
    6. 5. Using LinkedBlockingQueue
    7. 6. Using PriorityBlockingQueue
    8. 7. Using DelayQueue
    9. 8. Using SynchronousQueue
    10. 9. Using CopyOnWriteArrayList
    11. 10. Using CopyOnWriteArraySet
    12. 11. Using ConcurrentSkipListMap
    13. 12. Using ConcurrentSkipListSet
    14. 13. Choosing Concurrent Collections

  45. Working with Executor Framework

    1. 1. Understanding Executor Interface
    2. 2. Using ExecutorService
    3. 3. Creating Fixed Thread Pool
    4. Example: Fixed pool
    5. 4. Creating Cached Thread Pool
    6. 5. Creating Scheduled Thread Pool
    7. Example: Scheduled tasks
    8. 6. Creating Single Thread Executor
    9. 7. Creating Virtual Thread Per Task Executor
    10. Example: Virtual threads
    11. 8. Submitting Tasks
    12. 9. Using Future Interface
    13. 10. Cancelling Tasks
    14. 11. Shutting Down Executors
    15. 12. Configuring ThreadPoolExecutor
    16. Example: Custom pool
    17. 13. Using ForkJoinPool
    18. 14. Implementing Producer-Consumer Pattern
    19. Example: Producer-Consumer

  46. Working with CompletableFuture

    1. 1. Creating CompletableFuture
    2. 2. Running Tasks Asynchronously
    3. Example: Async
    4. 3. Chaining with thenApply()
    5. 4. Chaining with thenAccept()
    6. 5. Chaining with thenCompose()
    7. Example: thenCompose vs thenApply
    8. 6. Combining with thenCombine()
    9. 7. Handling Multiple Futures (allOf, anyOf)
    10. Example: allOf
    11. 8. Handling Exceptions
    12. 9. Using Custom Executors
    13. 10. Setting Timeouts
    14. Example: Timeout
    15. 11. Cancelling Futures
    16. 12. Getting Results
    17. 13. Composing Async Pipelines

  47. Working with Virtual Threads JAVA 21+

    1. 1. Understanding Virtual Threads
    2. 2. Creating Virtual Threads
    3. Example: Creation forms
    4. 3. Using Thread.ofVirtual() Builder
    5. 4. Comparing Virtual vs Platform Threads
    6. 5. Using Virtual Threads with Executors
    7. 6. Understanding Carrier Threads
    8. 7. Avoiding Pinning
    9. 8. Using Virtual Threads with HTTP Client
    10. 9. Migrating from Platform Threads
    11. 10. Performance Considerations

  48. Working with Structured Concurrency JAVA 21+ PREVIEW

    1. 1. Understanding StructuredTaskScope
    2. 2. Creating Structured Task Scopes
    3. 3. Using ShutdownOnFailure Strategy
    4. Example: ShutdownOnFailure
    5. 4. Using ShutdownOnSuccess Strategy
    6. 5. Forking Subtasks
    7. 6. Joining Subtasks
    8. 7. Handling Failures
    9. 8. Using Timeouts
    10. Example: Deadline
    11. 9. Cancelling Subtasks
    12. 10. Comparing with Traditional Concurrency

  49. Working with Scoped Values JAVA 21+ PREVIEW

    1. 1. Understanding Scoped Values
    2. 2. Creating Scoped Values
    3. 3. Binding Values
    4. Example: Binding
    5. 4. Reading Scoped Values
    6. 5. Scoping Rules
    7. 6. Comparing with ThreadLocal
    8. 7. Using with Virtual Threads
    9. 8. Inheritance in Structured Concurrency
    10. 9. Best Practices
    11. 10. Migration Strategies

  50. Working with Memory Management

    1. 1. Understanding Heap and Stack
    2. 2. Understanding Garbage Collection
    3. 3. Using Different Garbage Collectors
    4. 4. Tuning Heap Size
    5. 5. Understanding Generational GC
    6. 6. Using G1 Garbage Collector
    7. 7. Using ZGC
    8. 8. Monitoring Memory Usage
    9. 9. Detecting Memory Leaks
    10. 10. Using Weak References
    11. 11. Understanding finalize() Method
    12. 12. Using Cleaner Class
    13. Example: Cleaner
    14. 13. Best Practices for Memory

  51. Working with JVM Internals

    1. 1. Understanding JVM Architecture
    2. 2. Understanding Class Loading
    3. 3. Working with Class Loaders
    4. 4. Understanding Bytecode
    5. 5. Using JIT Compilation
    6. 6. Understanding Method Area
    7. 7. Understanding Runtime Constant Pool
    8. 8. Working with Native Methods
    9. 9. Using JNI
    10. 10. Understanding Foreign Function and Memory API
    11. Example: FFM
    12. 11. Using JVM Flags
    13. 12. Understanding Compilation Tiers
    14. 13. Using Class Data Sharing (CDS)

  52. Working with Performance Optimization

    1. 1. Profiling Java Applications
    2. 2. Using JMH for Benchmarking
    3. Example: JMH benchmark
    4. 3. Optimizing String Operations
    5. 4. Optimizing Collection Performance
    6. 5. Reducing Object Creation
    7. 6. Using Object Pooling Wisely
    8. 7. Optimizing I/O Operations
    9. 8. Tuning JVM Parameters
    10. 9. Understanding Escape Analysis
    11. 10. Using Inline Caches
    12. 11. Optimizing Lambda Performance
    13. 12. Reducing GC Pressure
    14. 13. Understanding Branch Prediction

  53. Working with Security

    1. 1. Understanding Java Security Architecture
    2. 2. Using SecurityManager
    3. 3. Working with Cryptography (JCA)
    4. Example: Symmetric encryption
    5. 4. Hashing Passwords
    6. 5. Using SSL/TLS
    7. 6. Working with Certificates
    8. 7. Implementing Authentication
    9. 8. Implementing Authorization
    10. 9. Preventing SQL Injection
    11. 10. Preventing XML/JSON Injection
    12. 11. Securing Deserialization
    13. Example: ObjectInputFilter
    14. 12. Validating Input
    15. 13. Using Secure Random

  54. Working with Debugging

    1. 1. Using IDE Debugger
    2. 2. Setting Breakpoints
    3. 3. Using jdb Command Line Debugger
    4. 4. Remote Debugging
    5. 5. Analyzing Thread Dumps
    6. Example: Get thread dump
    7. 6. Analyzing Heap Dumps
    8. 7. Using Java Flight Recorder (JFR)
    9. Example: JFR recording
    10. 8. Using Java Mission Control (JMC)
    11. 9. Reading Stack Traces
    12. 10. Logging Best Practices
    13. 11. Using Assertions
    14. 12. Common Debugging Patterns
    15. 13. Troubleshooting Performance Issues
    16. 14. Debugging Memory Issues
    17. 15. Debugging Concurrency Issues