Core Java Roadmap
54 sections • 787 topics
- 1. Declaring Integer Types
- Example: Integer literals
- 2. Working with Floating-Point Types
- Example: Float vs double
- 3. Using Character Type
- 4. Understanding Boolean Type
- 5. Understanding Default Values
- 6. Working with Literals
- 7. Understanding Type Casting
- 8. Using Wrapper Classes
- 9. Understanding Autoboxing and Unboxing
- 10. Comparing Primitives vs Wrapper Classes
- 1. Declaring Variables
- 2. Understanding Variable Scope
- 3. Understanding Type Inference
- 4. Working with Constants
- Example: Constants
- 5. Understanding Variable Shadowing
- 6. Using Static Variables
- Example: Static counter
- 7. Using Instance Variables
- 8. Understanding Variable Initialization
- 9. Working with System Properties
- 10. Working with Environment Variables
- 1. Using Arithmetic Operators (+, -, *, /, %)
- 2. Using Unary Operators (++, --, +, -, !)
- 3. Using Relational Operators (==, !=, >, <, >=, <=)
- 4. Using Logical Operators (&&, ||, !)
- 5. Using Bitwise Operators (&, |, ^, ~, <<, >>, >>>)
- 6. Using Assignment Operators (=, +=, -=, *=, /=)
- 7. Using Ternary Operator (? :)
- Example: Ternary
- 8. Understanding Operator Precedence
- 9. Using instanceof Operator
- Example: Pattern matching for instanceof
- 10. Understanding Short-Circuit Evaluation
- Example: Null-safe check
- 1. Using if-else Statements
- 2. Using Nested if Statements
- Example: Nested if
- 3. Using switch Statement (traditional)
- Example: Traditional switch
- 4. Using Switch Expressions
- Example: Switch expression with arrow
- 5. Understanding Pattern Matching in switch
- Example: Type and record patterns
- 6. Using for Loop
- 7. Using while Loop
- Example: while
- 8. Using do-while Loop
- Example: do-while
- 9. Using break Statement
- Example: Labeled break
- 10. Using continue Statement
- 11. Using return Statement
- 12. Using assert Statement
- 1. Declaring and Creating Arrays
- 2. Initializing Arrays
- Example: Initialization
- 3. Accessing Array Elements
- 4. Working with Multidimensional Arrays
- Example: 2D and jagged
- 5. Understanding Array Length
- 6. Iterating Arrays
- Example: Iteration patterns
- 7. Copying Arrays
- 8. Sorting Arrays
- 9. Searching Arrays
- 10. Comparing Arrays
- 11. Converting Arrays
- 12. Working with Varargs (...args)
- Example: Varargs method
- 1. Creating Strings
- 2. Understanding String Immutability
- 3. Understanding String Pool
- 4. Concatenating Strings
- 5. Comparing Strings
- 6. Extracting Substrings
- 7. Searching Strings
- 8. Modifying Strings
- 9. Splitting Strings
- 10. Formatting Strings
- 11. Converting Cases
- 12. Using StringBuilder
- Example: StringBuilder
- 13. Using StringBuffer
- 14. Working with Text Blocks
- Example: Text block
- 1. Using Text Blocks
- 2. Understanding Text Block Indentation
- Example: Indentation handling
- 3. Using Text Block Escape Sequences (\, \s, \n)
- 4. Using Text Block with formatted()
- Example: formatted
- 5. Using String.indent() Method
- 6. Using String.transform() Method
- Example: transform
- 7. Using String.isBlank() Method
- 8. Using String.lines() Method
- Example: Stream of lines
- 9. Using String.repeat() Method
- 10. Understanding String Templates
- 1. Using Math Class Methods
- 2. Working with Trigonometric Functions
- 3. Using Exponential Functions
- 4. Rounding Numbers
- 5. Generating Random Numbers
- 6. Using Random Class
- Example: Random
- 7. Using SecureRandom
- 8. Understanding Random Number Seeds
- 9. Working with BigInteger
- Example: BigInteger
- 10. Working with BigDecimal
- Example: Money math
- 1. Defining Classes
- Example: Class declaration
- 2. Creating Objects
- 3. Declaring Instance Variables
- 4. Defining Methods
- Example: Method signatures
- 5. Using this Keyword
- 6. Overloading Methods
- 7. Overloading Constructors
- Example: Constructor chaining
- 8. Understanding Static Members
- 9. Using Static Blocks
- Example: Static initializer
- 10. Working with Instance Initializer Blocks
- 11. Understanding Object Class Methods
- 12. Implementing equals() and hashCode()
- Example: equals + hashCode
- 13. Understanding Clone Method
- 1. Using Access Modifiers
- 2. Creating Getter Methods
- Example: Getters
- 3. Creating Setter Methods
- 4. Understanding Package-Private Access
- 5. Designing Immutable Classes
- 6. Understanding Information Hiding
- 7. Using JavaBeans Conventions
- 8. Working with Record Classes
- Example: Record
- 9. Understanding Record Components
- 10. Comparing Records vs Traditional Classes
- 1. Creating Subclasses
- Example: extends
- 2. Using super Keyword
- 3. Overriding Methods
- 4. Understanding Method Overriding Rules
- 5. Calling Parent Constructors (super())
- 6. Understanding Constructor Chaining
- Constructor chain
- 7. Using final Keyword
- 8. Understanding Object as Root Class
- 9. Working with instanceof and Type Checking
- Example: Pattern matching
- 10. Understanding Covariant Return Types
- Example: Covariant return
- 11. Understanding Method Overloading vs Overriding
- 1. Understanding Compile-Time Polymorphism
- 2. Understanding Runtime Polymorphism
- Example: Dynamic dispatch
- 3. Using Upcasting
- 4. Using Downcasting
- 5. Understanding Dynamic Method Dispatch
- 6. Working with Virtual Methods
- 7. Understanding Type Erasure in Generics
- 8. Using Polymorphic Collections
- Example: Polymorphic list
- 9. Understanding Late Binding
- 1. Defining Abstract Classes
- Example: Abstract class
- 2. Creating Abstract Methods
- 3. Implementing Abstract Classes
- 4. Defining Interfaces
- Example: Interface
- 5. Implementing Interfaces
- 6. Using Multiple Inheritance with Interfaces
- Example: Diamond resolution
- 7. Defining Default Methods
- 8. Defining Static Methods in Interfaces
- 9. Defining Private Methods in Interfaces
- 10. Understanding Functional Interfaces
- Example: Custom @FunctionalInterface
- 11. Working with Marker Interfaces
- 12. Understanding Interface vs Abstract Class
- 1. Declaring Sealed Classes
- Example: Sealed hierarchy
- 2. Using permits Clause
- 3. Creating Permitted Subclasses
- 4. Understanding Sealed Interfaces
- Example: Sealed interface
- 5. Combining Sealed Classes with Pattern Matching
- Example: Exhaustive switch
- 6. Understanding Exhaustiveness Checking
- 7. Using Sealed Classes for Domain Modeling
- 8. Comparing Sealed Classes vs Final Classes
- 1. Using Pattern Matching for instanceof
- Example: Auto-cast pattern
- 2. Understanding Type Patterns
- 3. Using Pattern Matching in switch
- Example: Switch with patterns
- 4. Using Guarded Patterns
- Example: when clause
- 5. Understanding Record Patterns
- Example: Record pattern
- 6. Deconstructing Records with Patterns
- 7. Using Nested Record Patterns
- Example: Nested deconstruction
- 8. Understanding Pattern Matching Exhaustiveness
- 9. Combining Patterns with Sealed Classes
- 10. Using Unnamed Patterns
- Example: Underscore for unused
- 1. Defining Static Nested Classes
- Example: Static nested
- 2. Defining Non-Static Inner Classes
- 3. Creating Local Classes
- Example: Local class
- 4. Creating Anonymous Classes
- Example: Anonymous class
- 5. Accessing Outer Class Members
- 6. Understanding .this Syntax
- Example: Outer.this
- 7. Using Inner Classes for Callbacks
- 8. Converting Anonymous to Lambda
- 9. Understanding Nested Class Use Cases
- 1. Defining Enums
- Example: Basic enum
- 2. Adding Fields to Enums
- Example: Enum with fields
- 3. Adding Methods to Enums
- 4. Adding Constructors to Enums
- 5. Using values() Method
- 6. Using valueOf() Method
- 7. Using ordinal() Method
- 8. Implementing Interfaces in Enums
- Example: Enum implements interface
- 9. Using EnumSet Collections
- Example: EnumSet
- 10. Using EnumMap Collections
- 11. Comparing Enums
- 12. Understanding Enum Singleton Pattern
- Example: Enum singleton
- 1. Creating Packages
- 2. Understanding Package Naming Conventions
- 3. Importing Classes
- 4. Using Wildcard Imports (import java.util.*)
- 5. Importing Static Members (import static)
- Example: Static import
- 6. Understanding Default Package
- 7. Resolving Package Conflicts
- Example: Conflict resolution
- 8. Organizing Code with Packages
- 9. Understanding CLASSPATH
- 10. Compiling Packages
- Example: javac with packages
- 1. Understanding Exception Hierarchy
- Exception hierarchy
- 2. Using try-catch Blocks
- Example: try-catch
- 3. Catching Multiple Exceptions
- Example: Multi-catch
- 4. Using finally Block
- 5. Using try-with-resources
- Example: Auto-close
- 6. Throwing Exceptions
- 7. Declaring Exceptions
- 8. Creating Custom Exceptions
- Example: Custom exception
- 9. Understanding Checked vs Unchecked Exceptions
- 10. Rethrowing Exceptions
- Example: Wrap and rethrow
- 11. Understanding Suppressed Exceptions
- 12. Using Exception Chaining
- 13. Understanding Best Practices
- 1. Creating Generic Classes
- Example: Generic class
- 2. Creating Generic Methods
- Example: Generic method
- 3. Using Bounded Type Parameters
- 4. Understanding Wildcards (?, extends, super)
- 5. Using Upper Bounded Wildcards (? extends T)
- Example: Producer of T
- 6. Using Lower Bounded Wildcards (? super T)
- Example: Consumer of T
- 7. Understanding Unbounded Wildcards (?)
- 8. Understanding Type Erasure
- 9. Working with Generic Arrays Limitations
- 10. Using Multiple Type Parameters
- Example: Pair
- 11. Understanding PECS Principle (Producer Extends Consumer Super)
- 12. Understanding Generic Method Inference
- 1. Understanding Collection Interface Hierarchy
- Collection hierarchy
- 2. Using ArrayList
- 3. Using LinkedList
- 4. Using Vector
- 5. Using Stack
- 6. Choosing List Implementation
- 7. Using HashSet
- 8. Using LinkedHashSet
- 9. Using TreeSet
- 10. Using HashMap
- Example: HashMap operations
- 11. Using LinkedHashMap
- 12. Using TreeMap
- 13. Using Hashtable
- 14. Understanding IdentityHashMap
- 1. Understanding SequencedCollection Interface
- 2. Using addFirst() and addLast() Methods
- Example: SequencedCollection ops
- 3. Using getFirst() and getLast() Methods
- 4. Using removeFirst() and removeLast() Methods
- 5. Using reversed() Method
- 6. Understanding SequencedSet Interface
- 7. Understanding SequencedMap Interface
- 8. Using firstEntry() and lastEntry() Methods
- Example: SequencedMap
- 9. Using pollFirstEntry() and pollLastEntry() Methods
- 10. Converting Legacy Collections to Sequenced
- 1. Understanding Queue Interface
- 2. Using PriorityQueue
- Example: Priority queue
- 3. Using ArrayDeque
- 4. Using LinkedList as Queue
- 5. Using offer(), poll(), peek() Methods
- 6. Understanding Deque Interface
- 7. Using addFirst(), addLast() Methods
- 8. Using removeFirst(), removeLast() Methods
- 9. Using Deque as Stack
- 10. Using Deque as Queue
- 1. Sorting Collections
- Example: Sort with comparator
- 2. Searching Collections
- 3. Reversing Collections
- 4. Shuffling Collections
- 5. Creating Unmodifiable Collections
- 6. Creating Synchronized Collections
- 7. Finding Min and Max
- 8. Replacing Elements
- 9. Copying Collections
- 10. Creating Singleton Collections
- 11. Using Frequency Method
- 12. Using Disjoint Method
- 1. Using Iterator Interface
- 2. Using ListIterator
- 3. Using Enhanced for Loop
- 4. Using forEach() Method
- Example: forEach
- 5. Implementing Comparable Interface
- Example: Comparable
- 6. Implementing Comparator Interface
- 7. Creating Comparator with Lambda
- Example: Lambda comparator
- 8. Chaining Comparators
- 9. Reversing Comparators
- 10. Using Comparator Factory Methods
- 11. Understanding Natural Ordering vs Custom Ordering
- 1. Understanding Lambda Syntax
- 2. Creating Single-Parameter Lambdas
- 3. Creating Multi-Parameter Lambdas
- Example: Multi-param
- 4. Using Block Lambdas
- 5. Understanding Effectively Final Variables
- 6. Using Method References (Class::method)
- 7. Using Constructor References (Class::new)
- Example: Constructor reference
- 8. Understanding Target Typing
- 9. Using Lambda with Collections
- 10. Replacing Anonymous Classes with Lambdas
- 11. Understanding Lambda Variable Scope
- 1. Using Predicate<T>
- 2. Using Function<T,R>
- Example: Function composition
- 3. Using Consumer<T>
- 4. Using Supplier<T>
- 5. Using UnaryOperator<T>
- 6. Using BinaryOperator<T>
- 7. Using BiPredicate<T,U>
- 8. Using BiFunction<T,U,R>
- 9. Using BiConsumer<T,U>
- 10. Creating Custom Functional Interfaces
- Example: Custom interface
- 11. Combining Predicates
- Example: Predicate composition
- 12. Composing Functions
- 1. Creating Streams
- 2. Using Intermediate Operations
- 3. Using Terminal Operations
- 4. Filtering Elements
- Example: Filter
- 5. Mapping Elements
- 6. Flattening Streams
- Example: flatMap
- 7. Sorting Streams
- 8. Removing Duplicates
- 9. Limiting Streams
- 10. Peeking Elements
- 11. Checking Conditions
- 12. Finding Elements
- 13. Understanding Parallel Streams
- 1. Using Stream.toList() Method
- 2. Using Stream.mapMulti() Method
- Example: mapMulti
- 3. Using Stream.teeing() Collector
- Example: teeing
- 4. Using Gatherers API
- 5. Creating Custom Gatherers
- Example: Custom gatherer
- 6. Using windowFixed() Gatherer
- Example: Fixed window
- 7. Using windowSliding() Gatherer
- 8. Using fold() Gatherer
- 9. Using scan() Gatherer
- 10. Composing Gatherers
- 1. Collecting to List
- 2. Collecting to Set
- 3. Collecting to Map
- Example: toMap
- 4. Joining Strings
- 5. Grouping Elements
- Example: groupingBy
- 6. Partitioning Elements
- 7. Counting Elements
- 8. Finding Statistics
- 9. Reducing Elements
- Example: reduce
- 10. Creating Custom Collectors
- 11. Collecting to Unmodifiable Collections
- 12. Using Downstream Collectors
- Example: Downstream chaining
- 1. Using LocalDate
- Example: LocalDate
- 2. Using LocalTime
- 3. Using LocalDateTime
- 4. Using ZonedDateTime
- Example: ZonedDateTime
- 5. Using Instant
- 6. Using Duration
- 7. Using Period
- 8. Formatting Dates
- Example: Format/parse
- 9. Parsing Dates
- 10. Manipulating Dates
- 11. Comparing Dates
- 12. Working with Time Zones
- 13. Understanding Clock Class
- 1. Working with Path Interface
- 2. Working with Files Class
- 3. Reading Files
- Example: Read patterns
- 4. Writing Files
- 5. Copying Files
- 6. Moving Files
- 7. Deleting Files
- 8. Checking File Existence
- 9. Creating Directories
- 10. Listing Directory Contents
- Example: Walk file tree
- 11. Using BufferedReader and BufferedWriter
- 12. Working with File Attributes
- 13. Using try-with-resources for I/O
- 14. Watching Directories
- Example: WatchService
- 1. Implementing Serializable Interface
- Example: Serializable
- 2. Using ObjectOutputStream
- 3. Using ObjectInputStream
- Example: Read object
- 4. Understanding serialVersionUID
- 5. Using transient Keyword
- 6. Customizing Serialization
- Example: Custom serialization
- 7. Implementing Externalizable Interface
- 8. Understanding Serialization Security Concerns
- 9. Handling Versioning Issues
- 10. Using Serialization Proxy Pattern
- 1. Understanding Pattern Class
- 2. Understanding Matcher Class
- 3. Using Character Classes ([abc], [^abc], [a-z])
- 4. Using Predefined Classes (\d, \w, \s)
- 5. Using Quantifiers (*, +, ?, {n}, {n,m})
- 6. Using Anchors (^, $, \b, \B)
- 7. Using Grouping and Capturing
- Example: Named groups
- 8. Using Alternation (|)
- 9. Replacing Text
- 10. Splitting Text
- 11. Using Flags
- 12. Understanding Greedy vs Reluctant vs Possessive
- 1. Using URL and URI Classes
- 2. Making HTTP Requests with HttpClient
- Example: Sync GET
- 3. Sending GET Requests
- 4. Sending POST Requests
- Example: POST JSON
- 5. Handling HTTP Responses
- 6. Making Async HTTP Requests
- Example: Async
- 7. Setting Request Headers
- 8. Working with Sockets
- 9. Implementing TCP Client/Server
- Example: Echo server
- 10. Implementing UDP Communication
- 11. Handling Network Errors
- 12. Setting Timeouts
- 13. Working with WebSockets
- Example: WebSocket client
- 1. Loading JDBC Drivers
- 2. Establishing Connections
- Example: Connection
- 3. Using Statement
- 4. Using PreparedStatement
- Example: PreparedStatement
- 5. Using CallableStatement
- 6. Working with ResultSet
- 7. Handling Transactions
- 8. Using Batch Processing
- Example: Batch insert
- 9. Handling SQL Exceptions
- 10. Using Connection Pools
- 11. Closing Resources Properly
- 12. Working with Database Metadata
- 1. Understanding Built-in Annotations
- 2. Using @Override
- 3. Using @Deprecated
- Example: Deprecation
- 4. Using @SuppressWarnings
- 5. Using @FunctionalInterface
- 6. Creating Custom Annotations
- Example: Custom annotation
- 7. Using @Target
- 8. Using @Retention
- 9. Using @Documented
- 10. Using @Inherited
- 11. Using @Repeatable
- Example: Repeatable
- 12. Processing Annotations at Runtime
- Example: Reflection
- 13. Using Annotation Processors
- 1. Getting Class Objects
- 2. Inspecting Class Information
- 3. Working with Fields
- Example: Field access
- 4. Working with Methods
- 5. Working with Constructors
- 6. Creating Instances Dynamically
- 7. Invoking Methods Dynamically
- 8. Accessing Private Members
- 9. Working with Generic Types
- 10. Using Class.forName()
- 11. Using ClassLoader
- 12. Understanding Reflection Performance
- 13. Using MethodHandles API
- Example: MethodHandle
- 1. Understanding Module System
- 2. Creating Module Declarations (module-info.java)
- Example: module-info
- 3. Using requires Directive
- 4. Using exports Directive
- 5. Using opens Directive
- 6. Using provides and uses Directives
- 7. Understanding Service Loading
- Example: ServiceLoader
- 8. Compiling Modular Applications
- 9. Running Modular Applications
- 10. Working with Automatic Modules
- 11. Understanding Unnamed Module
- 12. Migrating to Modules
- 13. Using jlink Tool
- Example: jlink
- 1. Creating Threads
- Example: Thread creation
- 2. Implementing Runnable Interface
- 3. Implementing Callable Interface
- 4. Understanding Thread Lifecycle
- 5. Using Thread Methods (start, sleep, join)
- 6. Setting Thread Priority
- 7. Creating Daemon Threads
- 8. Interrupting Threads
- 9. Handling InterruptedException
- Example: Handle interruption
- 10. Setting Thread Names
- 11. Using ThreadGroup
- 12. Understanding Thread Safety
- 13. Identifying Race Conditions
- 1. Using synchronized Keyword
- Example: synchronized
- 2. Synchronizing Methods
- 3. Synchronizing Blocks
- 4. Understanding Intrinsic Locks (Monitor)
- 5. Using Lock Interface
- Example: Lock
- 6. Using ReentrantLock
- 7. Using ReadWriteLock
- 8. Using StampedLock
- Example: Optimistic read
- 9. Using volatile Keyword
- 10. Understanding Atomic Operations
- 11. Using Atomic Classes
- Example: Atomic counter
- 12. Avoiding Deadlocks
- 13. Understanding Memory Model (JMM)
- 1. Using ConcurrentHashMap
- Example: ConcurrentHashMap
- 2. Using ConcurrentLinkedQueue
- 3. Using BlockingQueue
- 4. Using ArrayBlockingQueue
- 5. Using LinkedBlockingQueue
- 6. Using PriorityBlockingQueue
- 7. Using DelayQueue
- 8. Using SynchronousQueue
- 9. Using CopyOnWriteArrayList
- 10. Using CopyOnWriteArraySet
- 11. Using ConcurrentSkipListMap
- 12. Using ConcurrentSkipListSet
- 13. Choosing Concurrent Collections
- 1. Understanding Executor Interface
- 2. Using ExecutorService
- 3. Creating Fixed Thread Pool
- Example: Fixed pool
- 4. Creating Cached Thread Pool
- 5. Creating Scheduled Thread Pool
- Example: Scheduled tasks
- 6. Creating Single Thread Executor
- 7. Creating Virtual Thread Per Task Executor
- Example: Virtual threads
- 8. Submitting Tasks
- 9. Using Future Interface
- 10. Cancelling Tasks
- 11. Shutting Down Executors
- 12. Configuring ThreadPoolExecutor
- Example: Custom pool
- 13. Using ForkJoinPool
- 14. Implementing Producer-Consumer Pattern
- Example: Producer-Consumer
- 1. Creating CompletableFuture
- 2. Running Tasks Asynchronously
- Example: Async
- 3. Chaining with thenApply()
- 4. Chaining with thenAccept()
- 5. Chaining with thenCompose()
- Example: thenCompose vs thenApply
- 6. Combining with thenCombine()
- 7. Handling Multiple Futures (allOf, anyOf)
- Example: allOf
- 8. Handling Exceptions
- 9. Using Custom Executors
- 10. Setting Timeouts
- Example: Timeout
- 11. Cancelling Futures
- 12. Getting Results
- 13. Composing Async Pipelines
- 1. Understanding Virtual Threads
- 2. Creating Virtual Threads
- Example: Creation forms
- 3. Using Thread.ofVirtual() Builder
- 4. Comparing Virtual vs Platform Threads
- 5. Using Virtual Threads with Executors
- 6. Understanding Carrier Threads
- 7. Avoiding Pinning
- 8. Using Virtual Threads with HTTP Client
- 9. Migrating from Platform Threads
- 10. Performance Considerations
- 1. Understanding StructuredTaskScope
- 2. Creating Structured Task Scopes
- 3. Using ShutdownOnFailure Strategy
- Example: ShutdownOnFailure
- 4. Using ShutdownOnSuccess Strategy
- 5. Forking Subtasks
- 6. Joining Subtasks
- 7. Handling Failures
- 8. Using Timeouts
- Example: Deadline
- 9. Cancelling Subtasks
- 10. Comparing with Traditional Concurrency
- 1. Understanding Heap and Stack
- 2. Understanding Garbage Collection
- 3. Using Different Garbage Collectors
- 4. Tuning Heap Size
- 5. Understanding Generational GC
- 6. Using G1 Garbage Collector
- 7. Using ZGC
- 8. Monitoring Memory Usage
- 9. Detecting Memory Leaks
- 10. Using Weak References
- 11. Understanding finalize() Method
- 12. Using Cleaner Class
- Example: Cleaner
- 13. Best Practices for Memory
- 1. Understanding JVM Architecture
- 2. Understanding Class Loading
- 3. Working with Class Loaders
- 4. Understanding Bytecode
- 5. Using JIT Compilation
- 6. Understanding Method Area
- 7. Understanding Runtime Constant Pool
- 8. Working with Native Methods
- 9. Using JNI
- 10. Understanding Foreign Function and Memory API
- Example: FFM
- 11. Using JVM Flags
- 12. Understanding Compilation Tiers
- 13. Using Class Data Sharing (CDS)
- 1. Profiling Java Applications
- 2. Using JMH for Benchmarking
- Example: JMH benchmark
- 3. Optimizing String Operations
- 4. Optimizing Collection Performance
- 5. Reducing Object Creation
- 6. Using Object Pooling Wisely
- 7. Optimizing I/O Operations
- 8. Tuning JVM Parameters
- 9. Understanding Escape Analysis
- 10. Using Inline Caches
- 11. Optimizing Lambda Performance
- 12. Reducing GC Pressure
- 13. Understanding Branch Prediction
- 1. Understanding Java Security Architecture
- 2. Using SecurityManager
- 3. Working with Cryptography (JCA)
- Example: Symmetric encryption
- 4. Hashing Passwords
- 5. Using SSL/TLS
- 6. Working with Certificates
- 7. Implementing Authentication
- 8. Implementing Authorization
- 9. Preventing SQL Injection
- 10. Preventing XML/JSON Injection
- 11. Securing Deserialization
- Example: ObjectInputFilter
- 12. Validating Input
- 13. Using Secure Random
- 1. Using IDE Debugger
- 2. Setting Breakpoints
- 3. Using jdb Command Line Debugger
- 4. Remote Debugging
- 5. Analyzing Thread Dumps
- Example: Get thread dump
- 6. Analyzing Heap Dumps
- 7. Using Java Flight Recorder (JFR)
- Example: JFR recording
- 8. Using Java Mission Control (JMC)
- 9. Reading Stack Traces
- 10. Logging Best Practices
- 11. Using Assertions
- 12. Common Debugging Patterns
- 13. Troubleshooting Performance Issues
- 14. Debugging Memory Issues
- 15. Debugging Concurrency Issues