Premium

Complete Java Developer Course

Basic Java

Introduction

About the course

Platform features

Java Basics

First Program

Variables and Types

Operators

Conditions

Loops

Methods

Arrays

Strings

OOP

Classes and Objects

Constructors and Fields

Encapsulation

Inheritance

Polymorphism

Abstract Classes and Interfaces

Object Class

Equals, hashCode and toString

Static and final

Nested Classes

Enums

Exceptions

Exception Hierarchy

Try, catch and finally

Throw and throws

Checked and Unchecked Exceptions

Custom Exceptions

Try-with-resources

Exception Best Practices

Collections and Generics

Generics

Collection Hierarchy

List

Set

Queue and Deque

Map

ArrayList and LinkedList

HashMap

HashSet

Comparable and Comparator

Iterator and Iterable

Collections Utility Class

Stream API and Lambda

Lambda Expressions

Functional Interfaces

Method References

Stream API Basics

Intermediate Operations

Terminal Operations

Collectors

Optional

Primitive Streams

Parallel Streams

Date and Time

LocalDate, LocalTime and LocalDateTime

Instant and Timestamps

ZoneId and ZonedDateTime

Duration and Period

DateTimeFormatter

Date and Time Operations

Temporal API

Legacy Date API

IO and NIO

File and Path

Byte Streams

Character Streams

Buffered I/O

Files Class

Channels and Buffers

Serialization

Resources and Try-with-Resources

Annotations and Reflection

Annotation Basics

Built-in Annotations

Custom Annotations

Retention and Target

Reflection Basics

Class, Fields and Methods

Dynamic Access with Reflection

Reflection Limitations and Considerations

JDBC

JDBC Basics

Connection

Statement and PreparedStatement

ResultSet

JDBC Transactions

Batch Operations

Generated Keys

Connection Pooling

JPA

JPA Basics

Entity

Entity Lifecycle

Entity Relationships

Fetch Types and Data Loading

Cascade Operations

Persistence Context

JPQL

JPA Transactions

N+1 Problem

Advanced Java

Concurrency

Thread Basics

Runnable and Callable

ExecutorService

Future and CompletableFuture

Synchronization

Lock and ReentrantLock

Concurrent Collections

Atomic Classes

Thread Pools

Virtual Threads

JMM

Java Memory Model Basics

Visibility and Atomicity

Happens-Before

Volatile

Synchronized Memory Semantics

Final Fields and Safe Publication

Instruction Reordering

Data Races and Race Conditions

JVM

JVM Architecture

Class Loading

ClassLoaders

JVM Runtime Memory Areas

Stack and Heap

Garbage Collection

GC Algorithms

JIT Compilation

Bytecode

JVM Monitoring and Diagnostics

Testing

Testing Basics

JUnit

Assertions

Parameterized Tests

Mockito

Mock and Spy

Unit and Integration Tests

Testcontainers

Testing Best Practices

Project Build

Build Tools

Maven

Gradle

Dependencies

Build Lifecycle

Plugins

Multi-Module Projects

Build Artifacts

Design Patterns

Design Pattern Basics

Creational Patterns

Singleton

Factory Method

Abstract Factory

Builder

Prototype

Structural Patterns

Adapter

Bridge

Composite

Decorator

Facade

Proxy

Behavioral Patterns

Chain of Responsibility

Command

Iterator

Mediator

Memento

Observer

State

Strategy

Template Method

Visitor

Basic Spring

Introduction

About the course

Platform features

Spring Core

IoC and Dependency Injection

ApplicationContext

Spring Beans

Bean Lifecycle

Bean Scopes

Component Scanning

Java Configuration

BeanPostProcessor

Spring Events

Spring AOP

Spring Proxies

Spring Boot

Spring Boot Basics

Starters

Auto-configuration

Application Configuration

Configuration Properties

Profiles

Logging

Actuator

Application Startup

Spring MVC

Spring MVC Basics

DispatcherServlet

Controllers

Request Mapping

Request Parameters

RequestBody and ResponseBody

REST Controllers

Validation

Exception Handling

Filters and Interceptors

HttpMessageConverters

Spring Data JDBC

Spring Data JDBC Basics

Repositories

CrudRepository

Entity Mapping

Queries

Custom Queries

Relationships and Aggregates

Auditing

Spring Data JPA

Repositories

JpaRepository

Derived Queries

@Query

Pagination and Sorting

Specifications

Projections

Auditing

Advanced Spring

Transactions

Transaction Basics

@Transactional

TransactionManager

Propagation

Isolation

Rollback

Read-only Transactions

Transactions and Spring Proxies

Self Invocation Problem

Programmatic Transactions

Spring Security

Spring Security Basics

SecurityFilterChain

Authentication

Authorization

UserDetailsService

PasswordEncoder

Session Authentication

CSRF

CORS

Method Security

JWT

OAuth2

Spring Testing

Spring Test

Spring Boot Test

@SpringBootTest

TestContext

MockMvc

@WebMvcTest

@DataJpaTest

Integration Tests

Spring Cloud

Spring Cloud Basics

Spring Cloud Config

OpenFeign

Service Discovery

Spring Cloud Gateway

Circuit Breaker

Basic SQL

Introduction

About the course

Platform features

SQL Basics

SQL Syntax

Data Types

DDL

DML

SELECT

Constraints

Primary Key and Foreign Key

NULL

Filtering and Sorting

WHERE

Comparison Operators

AND, OR and NOT

IN, BETWEEN and LIKE

IS NULL and IS NOT NULL

ORDER BY

LIMIT and OFFSET

Aggregation

Aggregate Functions

COUNT

SUM, AVG, MIN and MAX

GROUP BY

HAVING

Grouping by Multiple Columns

Joins

JOIN Basics

INNER JOIN

LEFT JOIN

RIGHT JOIN

FULL JOIN

CROSS JOIN

SELF JOIN

Multiple JOINs

Subqueries

Subqueries

Scalar Subqueries

Subqueries in WHERE

EXISTS and NOT EXISTS

Correlated Subqueries

CTE

Recursive CTE

Advanced SQL

Indexes

Index Basics

B-tree Indexes

Unique Index

Composite Indexes

Index Column Order

Covering Indexes

When Indexes Are Not Used

Transactions and ACID

Transaction Basics

BEGIN, COMMIT and ROLLBACK

Atomicity

Consistency

Isolation

Durability

Savepoints

Isolation Levels

Concurrency Anomalies

Dirty Read

Non-repeatable Read

Phantom Read

Read Uncommitted

Read Committed

Repeatable Read

Serializable

Locks and Deadlocks

Locking Basics

Shared and Exclusive Locks

Row and Table Locks

Explicit Locking

SELECT FOR UPDATE

Deadlocks

Deadlock Prevention

Normalization

Normalization Basics

Functional Dependencies

First Normal Form

Second Normal Form

Third Normal Form

BCNF

Denormalization

Optimization

SQL Query Execution

EXPLAIN

EXPLAIN ANALYZE

Execution Plan

Seq Scan and Index Scan

JOIN Algorithms

Query Rewriting

Optimization Best Practices

Basic Algorithms

Introduction

About the course

Platform features

Algorithm Basics

Brute Force

Counting

Minimum and Maximum

Working with Digits

Divisibility

Math Problems

Big O

Complexity Basics

Time Complexity

Space Complexity

Common Complexity Classes

Amortized Complexity

Best, Average and Worst Case

Arrays

Array Basics

Array Traversal

Two Pointers

Sliding Window

Prefix Sums

In-place Operations

Matrices

Strings

String Basics

Character Counting

Two Pointers

Sliding Window

Palindromes

Anagrams

Substring Problems

Linked Lists

Linked List Basics

Singly Linked List

Doubly Linked List

Fast and Slow Pointers

Reverse Linked List

Cycle Detection

Merge Linked Lists

Hash Tables

Hash Table Basics

Hash Functions

Collisions

Hash Map

Hash Set

Frequency Map

Fast Lookup Patterns

Stacks and Queues

Stack

Queue

Deque

Monotonic Stack

Monotonic Queue

Parentheses Problems

Queue Using Stacks

Sorting

Sorting Basics

Bubble Sort

Selection Sort

Insertion Sort

Merge Sort

Quick Sort

Counting Sort

Stable Sorting

Binary Search

Binary Search Basics

Search in a Sorted Array

Lower Bound and Upper Bound

First and Last Position

Rotated Sorted Array

Binary Search on the Answer

Advanced Algorithms

Recursion

Recursion Basics

Base Case

Call Stack

Recursion Tree

Divide and Conquer

Recursion vs Iteration

Trees

Tree Basics

Binary Tree

Binary Search Tree

DFS

BFS

Tree Traversals

Tree Height and Depth

Lowest Common Ancestor

Graphs

Graph Basics

Graph Representation

DFS

BFS

Connected Components

Cycle Detection

Topological Sort

Shortest Path

Backtracking

Backtracking Basics

Decision Tree

Subsets

Permutations

Combinations

Constraint Problems

Greedy Algorithms

Greedy Basics

Greedy Choice

Interval Problems

Activity Selection

Greedy vs Dynamic Programming

When Greedy Works

Dynamic Programming

Dynamic Programming Basics

Memoization

Tabulation

DP State

DP Transitions

One-dimensional DP

Two-dimensional DP

DP Memory Optimization

Basic System Design

Introduction

About the course

Platform features

System Design Basics

System Design Process

Functional Requirements

Non-functional Requirements

Latency and Throughput

Availability and Reliability

Stateless and Stateful

Architecture Trade-offs

Load Estimation

Load Estimation Basics

RPS and QPS

Peak Load

Storage Estimation

Bandwidth Estimation

Back-of-the-envelope Estimation

System Components

DNS

CDN

Reverse Proxy

Load Balancer

API Gateway

Application Server

Service Discovery

Data Storage

Storage Requirements

SQL vs NoSQL

Relational Databases

Key-Value Stores

Document Databases

Column Databases

Object Storage

Choosing a Storage

Caching

Caching Basics

Cache-Aside

Read-Through

Write-Through

Write-Back

TTL and Eviction

Cache Invalidation

Distributed Cache

Service Communication

Service Communication Basics

Synchronous Communication

Asynchronous Communication

REST

gRPC

Messaging

Request-Response

Publish-Subscribe

Idempotency

Monolith and Microservices

Monolith

Modular Monolith

Microservices Basics

Service Decomposition

Service Boundaries

Database per Service

Migration to Microservices

Microservices Trade-offs

Advanced System Design

Distributed Systems

Distributed Systems Basics

Replication

Partitioning

Failure Models

Distributed Coordination

Leader Election

Consensus

Clocks and Event Ordering

Scalability

Scalability Basics

Vertical and Horizontal Scaling

Stateless Scaling

Load Balancing

Database Scaling

Read Replicas

Sharding

Hotspots

Autoscaling

Data and Consistency

Data Ownership

Consistency Models

Strong Consistency

Eventual Consistency

Quorum

Distributed Transactions

Two-Phase Commit

Saga

Data Synchronization

Event-Driven Architecture

Event-Driven Architecture Basics

Events

Event Brokers

Event Streaming

Delivery Semantics

Event Ordering

Event Sourcing

CQRS

Transactional Outbox

Reliability and Fault Tolerance

Reliability Basics

Timeouts

Retries and Backoff

Circuit Breaker

Bulkhead

Rate Limiting

Fault Tolerance

Graceful Degradation

Health Checks

Observability

Observability Basics

Logging

Metrics

Distributed Tracing

Correlation IDs

Alerting

SLI, SLO and SLA

Incident Response

System Security

Security Basics

Authentication

Authorization

TLS

Secrets Management

Network Security

Data Encryption

Threat Modeling

Designing Systems

System Design Framework

URL Shortener

Pastebin

Notification System

Chat System

News Feed

File Storage

Video Streaming

Ride-hailing Service

Design Review