Java Tutorials — Complete Beginner to Advanced Guide

What Is Java? History, JVM, and the Ecosystem

Java is a class-based, object-oriented programming language designed for platform independence through the Java Virtual Machine. This lesson covers its history, WORA principle, Java SE/EE/ME editions, and the Oracle JDK vs OpenJDK distinction.

JavaScript Tutorials

JavaScript brings web pages to life — dynamic content, interactive forms, real-time updates, and full-featured web apps.

Installing Java — JDK Setup, PATH Configuration, and Your First Compilation

Installing Java requires downloading a JDK, setting environment variables, and verifying the installation with javac and java commands. This lesson walks through the complete setup process on Windows, macOS, and Linux.

Hello World — Class Declaration, main Method, and Compilation Process

The Hello World program in Java demonstrates class declaration, the main method signature, compilation to bytecode, and execution on the JVM. This lesson dissects every keyword and symbol in the simplest Java program.

Variables and Data Types — Primitives, Type Conversion, var, and Default Values

Java variables are strongly typed containers for data, with eight primitive types and a unified type system. This lesson covers the primitives, type conversion rules, the var keyword for local type inference, and how default values work for fields.

Operators — Arithmetic, Relational, Logical, Bitwise, Assignment, and Precedence

Java operators are symbols that perform operations on operands, ranging from basic arithmetic to bitwise manipulation. This lesson covers all operator categories, their behavior, common pitfalls, and the precedence table that governs evaluation order.

Control Flow — if, else, switch, Ternary Operator, and Pattern Matching

Control flow statements in Java direct the order of execution based on conditions, with if/else, switch expressions, the ternary operator, and pattern matching. This lesson explains each construct with emphasis on switch expressions (Java 14+) and pattern matching (Java 17+).

Loops — for, while, do-while, for-each, break, continue, and Labeled Loops

Loops in Java execute a block of code repeatedly, with for, while, do-while, and for-each constructs providing different iteration strategies. This lesson covers each loop type, controlling flow with break and continue, and using labeled loops for nested iteration.

Arrays — Declaration, Initialization, Multi-Dimensional, and the Arrays Utility Class

Java arrays are fixed-length containers that hold elements of a single type, providing fast indexed access. This lesson covers declaration syntax, initialization patterns, multi-dimensional arrays, the System.arraycopy method, and the rich Arrays utility class.

Methods — Parameters, Return Types, Overloading, Varargs, and Method References

Java methods are reusable blocks of code that accept parameters, return values, and can be overloaded with different signatures. This lesson covers method declaration, parameter passing, overloading, varargs, and method references introduced in Java 8.

Strings — String Pool, Immutability, StringBuilder, StringBuffer, and Text Blocks

Java strings are immutable sequences of characters stored in a special memory area called the string pool. This lesson covers string immutability, the StringBuilder and StringBuffer classes for efficient manipulation, and text blocks for multi-line strings.

Classes and Objects — Constructors, this, Instance vs Static, and Initialization Blocks

Java classes are blueprints for objects, encapsulating state and behavior through fields, methods, constructors, and initialization blocks. This lesson covers constructors, the this keyword, instance vs static members, and initialization order.

Encapsulation — Access Modifiers, Getters/Setters, JavaBeans, and Data Hiding

Encapsulation in Java hides internal object state and exposes controlled access through getters and setters, enforced by access modifiers. This lesson covers the four access levels, the JavaBeans convention, and why data hiding is a cornerstone of maintainable software.

Inheritance — extends, super, Method Overriding, and the Object Class

Inheritance in Java allows a class to derive from another class, inheriting its fields and methods, using the extends keyword. This lesson covers the super keyword, method overriding rules, and the methods all classes inherit from Object.

Polymorphism — Compile-Time Overloading, Runtime Overriding, and Covariant Types

Polymorphism in Java allows objects to take many forms, with compile-time polymorphism via method overloading and runtime polymorphism via method overriding. This lesson explains both types, covariant return types, and how polymorphism enables extensible frameworks.

Abstract Classes — Abstract Methods, Template Method Pattern, and Anonymous Classes

Abstract classes in Java cannot be instantiated and may contain abstract methods that subclasses must implement. This lesson covers abstract class design, the template method pattern, and anonymous classes that implement or extend types inline.

Interfaces — implements, Default/Static/Private Methods, and Functional Interfaces

Java interfaces define contracts that classes implement, evolving beyond pure abstraction to include default, static, and private methods. This lesson covers interface declaration, multiple inheritance of type, default method resolution, and functional interfaces for lambdas.

Packages and Imports — Naming Conventions, import, module-info.java, and JPMS

Java packages organize classes into namespaces, preventing name collisions and enabling access control. This lesson covers package declaration, import statements, package naming conventions, and the Java Platform Module System (JPMS) introduced in Java 9.

Enums — Type-Safe Constants with Fields, Methods, EnumMap, and EnumSet

Java enums provide type-safe constants that are more powerful than integer constants, supporting fields, methods, and specialized collections. This lesson covers enum declaration with fields and methods, switch with enums, and the EnumMap and EnumSet classes.

Records — Compact Data Carriers, Canonical Constructors, and Components (Java 14+)

Java records are transparent data carriers that automatically generate constructors, accessors, equals, hashCode, and toString from component declarations. This lesson covers record declaration, compact constructors, custom methods, and integration with other Java features.

Sealed Classes — Permits, Sealed Interfaces, and Exhaustive Switches (Java 17+)

Sealed classes in Java restrict which other classes can extend or implement them, enabling exhaustive pattern matching. This lesson covers sealed class declaration, the permits clause, sealed interfaces, and exhaustive switch with sealed types.

Exception Handling — try/catch/finally, Checked vs Unchecked, and Try-With-Resources

Java exception handling separates error-handling code from normal execution flow using try, catch, finally, and throw keywords. This lesson covers checked vs unchecked exceptions, the try-with-resources statement, and best practices for robust error handling.

Custom Exceptions — Creating Exception Types, Chained Exceptions, and Best Practices

Custom exceptions in Java extend Exception or RuntimeException to represent domain-specific error conditions. This lesson covers creating custom exception classes, exception chaining, and design patterns for meaningful, actionable exception hierarchies.

Collections List — ArrayList, LinkedList, Vector, CopyOnWriteArrayList, and Iteration

The List interface in Java represents an ordered collection that allows duplicate elements, with implementations optimized for different access patterns. This lesson covers ArrayList, LinkedList, Vector, CopyOnWriteArrayList, and safe iteration techniques.

Collections Set — HashSet, TreeSet, LinkedHashSet, SortedSet, and NavigableSet

Java Set interface represents collections with no duplicate elements, with implementations optimized for fast membership testing and ordering requirements. This lesson covers HashSet, TreeSet, LinkedHashSet, and the ordering interfaces SortedSet and NavigableSet.

Collections Map — HashMap, TreeMap, LinkedHashMap, EnumMap, and IdentityHashMap

The Java Map interface stores key-value pairs, with implementations optimized for different ordering and performance requirements. This lesson covers HashMap, TreeMap, LinkedHashMap, EnumMap, and IdentityHashMap with their use cases.

Collections Queue — PriorityQueue, ArrayDeque, and BlockingQueue Implementations

Java Queue and Deque interfaces represent collections for holding elements prior to processing, with FIFO, priority, and LIFO semantics. This lesson covers PriorityQueue, ArrayDeque, and BlockingQueue implementations for single-threaded and concurrent use.

Generics — Type Parameters, Wildcards, Bounded Types, Type Erasure, and PECS

Java generics enable type-safe programming by parameterizing types, eliminating casts and enabling compile-time type checking. This lesson covers type parameters, wildcards (? extends / ? super), bounded type parameters, type erasure, and the PECS principle.

Equals and HashCode — The Contract, Implementation, and Best Practices

The equals and hashCode methods define object equality and hash-based collection behavior in Java, with a strict contract that both must be overridden together. This lesson covers the contract, correct implementation patterns, and automatic generation with Lombok and records.

Comparable and Comparator — Natural Ordering, Comparator.comparing, and thenComparing

Java provides Comparable for natural ordering and Comparator for custom ordering, both enabling sorting and ordered collections. This lesson covers implementing Comparable, using Comparator.comparing factory methods, and chaining comparisons with thenComparing.

Date and Time — LocalDate, LocalTime, ZonedDateTime, Duration, Period, and Formatting

Java's java.time package provides a comprehensive, immutable date and time API that replaced the legacy Date and Calendar classes. This lesson covers LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Duration, Period, and DateTimeFormatter for parsing and formatting.

Scanner and Basic I/O — Reading Input, Console, System Streams, and printf Formatting

Java's Scanner class provides flexible text parsing for user input, while Console, System.in/out/err, and printf handle basic I/O operations. This lesson covers reading input, formatting output, and best practices for interactive programs.

Math and BigDecimal — Math Class, BigInteger, BigDecimal, and Rounding Modes

Java provides the Math class for basic mathematical operations, BigInteger for arbitrary-precision integers, and BigDecimal for precise decimal arithmetic essential in financial calculations. This lesson covers all three with emphasis on correct rounding behavior.

Lambda Expressions — Syntax, Target Typing, Variable Capture, and Method References

Lambda expressions in Java enable functional programming by providing concise syntax for implementing functional interfaces. This lesson covers lambda syntax, target typing, effectively final variables, and method references for cleaner code.

Stream API — Creation, Intermediate Ops, Terminal Ops, and Parallel Streams

The Java Stream API processes sequences of elements with functional-style operations, enabling declarative data processing pipelines. This lesson covers stream creation, intermediate operations (map, filter, flatMap, distinct, sorted), terminal operations (collect, reduce, count, forEach), and parallel streams.

Stream Collectors — toList, groupingBy, partitioningBy, mapping, and teeing

Java stream collectors transform stream elements into various result containers using the Collectors utility class. This lesson covers common collectors like toList and toSet, groupingBy for partitioning into maps, partitioningBy for boolean splits, mapping for downstream transformations, and the teeing collector for two-result aggregation.

Optional — Creation, map/flatMap, orElse, ifPresent, and Best Practices

Java Optional is a container object that may or may not contain a non-null value, providing a functional alternative to null checks. This lesson covers Optional creation, mapping, default values, conditional actions, and when to use (and not use) Optional.

CompletableFuture — Asynchronous Programming with supplyAsync, thenCompose, and Exception Handling

CompletableFuture in Java enables asynchronous, non-blocking programming with a composable future API for tasks that may complete in a different thread. This lesson covers creating futures, chaining dependent stages, combining multiple futures, and proper exception handling.

Functional Interfaces — Predicate, Function, Consumer, Supplier, and Custom FIs

Java's java.util.function package provides standard functional interfaces for lambda expressions, covering predicates, functions, consumers, and suppliers. This lesson covers the core interfaces, specialized variants for primitives, and creating custom functional interfaces.

File I/O Streams — FileInputStream, FileOutputStream, Buffered Streams, and Data Streams

Java I/O streams provide sequential access to data sources, with FileInputStream and FileOutputStream for binary file operations. This lesson covers byte streams, buffered streams for performance, and data streams for primitive type I/O.

JavaScript Optional Chaining — Complete Guide

Learn JavaScript optional chaining (?.) to safely access deeply nested object properties without writing manual null checks at every single level of the chain.

Readers and Writers — FileReader, FileWriter, BufferedReader, and InputStreamReader

Java Reader and Writer classes handle character-based I/O, correctly encoding characters to bytes using specified character sets. This lesson covers FileReader, FileWriter, BufferedReader, BufferedWriter, and InputStreamReader for bridging byte streams to character streams.

JavaScript Nullish Coalescing — Complete Guide

Learn the JavaScript nullish coalescing operator (??) that returns its right operand only when the left operand is null or undefined, not other falsy values.

NIO.2 Files — Path, Files Utility Methods, walk, find, lines, and File Operations

Java NIO.2 (introduced in Java 7) provides a modern file system API centered on the Path class and Files utility, replacing much of java.io. This lesson covers Path, Files methods for reading/writing, walking directory trees, finding files, and performing copy/move/delete operations.

JavaScript Logical Assignment — Complete Guide

Learn JavaScript logical assignment operators (&&=, ||=, ??=) that combine logical operations with assignment for more concise conditional variable updates.

NIO Channels and Buffers — FileChannel, ByteBuffer, SocketChannel, and Selectors

Java NIO channels and buffers provide high-performance I/O operations with non-blocking capabilities and direct memory access. This lesson covers FileChannel for file I/O, ByteBuffer for data buffering, SocketChannel for network communication, and Selectors for multiplexed I/O.

JavaScript Numeric Separator — Complete Guide

Learn JavaScript numeric separators using underscores to make large numbers readable, improving code clarity without affecting the underlying numeric value.

Serialization — Serializable, transient, ObjectOutputStream, readObject, and Versioning

Java serialization converts objects into a byte stream for persistence or transmission, using the Serializable marker interface. This lesson covers the serialization mechanism, transient fields, custom readObject/writeObject, and versioning with serialVersionUID.

JavaScript replaceAll — Complete Guide

Learn JavaScript replaceAll for replacing all occurrences of a substring in a string without using a global regex, simplifying common text transformation tasks.

Properties and Configuration — Properties, ResourceBundle, Config Files, and Preferences API

Java Properties and ResourceBundle classes manage configuration data and internationalized messages through key-value pairs. This lesson covers loading and saving .properties files, locale-specific resource bundles, and the Preferences API for user-specific settings.

JavaScript Promise.any — Complete Guide

Learn JavaScript Promise.any that resolves with the first fulfilled promise, short-circuiting on success and aggregating errors only if every promise rejects.

Maven — POM.xml, Build Lifecycle, Dependencies, Plugins, and Multi-Module Projects

Apache Maven is a build automation and project management tool that uses a Project Object Model (POM) for configuration. This lesson covers pom.xml structure, the build lifecycle (validate, compile, test, package, verify, install, deploy), dependency management, plugins, and multi-module projects.

JavaScript Promise.allSettled — Complete Guide

Learn JavaScript Promise.allSettled that waits for all promises to settle regardless of fulfillment or rejection, returning an array of result objects.

Gradle — Build.gradle, Kotlin DSL, Tasks, Dependencies, and the Gradle Wrapper

Gradle is a build automation tool that uses a Groovy or Kotlin DSL for declarative configuration and incremental builds. This lesson covers build.gradle structure, the Kotlin DSL syntax, task dependencies, dependency management, and the Gradle wrapper for reproducible builds.

JUnit 5 — @Test, Assertions, Assumptions, Parameterized Tests, and Test Lifecycle

JUnit 5 is the standard testing framework for Java, providing annotations, assertions, and extension points for writing and running tests. This lesson covers the JUnit 5 architecture, @Test, assertions, assumptions, parameterized tests, and the test lifecycle.

Mockito — Mocking, Stubs, Verify, BDDMockito, ArgumentCaptor, and Spy

Mockito is the most popular Java mocking framework, enabling creation of mock objects for isolating code under test. This lesson covers @Mock and @InjectMocks, stubbing with when/thenReturn, verification with verify, BDD-style mocking, ArgumentCaptor for capturing arguments, and partial mocking with spies.

Integration Testing — Testcontainers, @SpringBootTest, and Embedded Databases

Integration testing validates the interaction between components in a running application context, using Testcontainers for real database testing and @SpringBootTest for Spring Boot integration tests. This lesson covers Testcontainers, @SpringBootTest, and embedded database strategies.

Logging — SLF4J, Logback, Log4j2, MDC, Structured Logging, and Log Levels

Java logging frameworks capture runtime information for debugging, monitoring, and auditing, with SLF4J as the standard abstraction layer. This lesson covers SLF4J, Logback configuration, Log4j2, MDC for contextual logging, structured logging with JSON, and best practices for log levels.

Threads and Runnable — Thread Class, Runnable, Callable, Thread States, and Daemon Threads

Java threads enable concurrent execution within a single process, with the Thread class and Runnable interface providing the foundation. This lesson covers creating threads, the thread lifecycle, daemon threads, the Callable interface for return values, and thread coordination.

Synchronization — synchronized, volatile, Atomic Classes, and Happens-Before

Java synchronization coordinates access to shared mutable data across threads using the synchronized keyword, volatile variables, and atomic classes. This lesson covers the Java Memory Model, synchronized blocks, the volatile keyword, java.util.concurrent.atomic classes, and the happens-before relationship.

Locks — ReentrantLock, ReadWriteLock, StampedLock, and Condition

Java's java.util.concurrent.locks package provides advanced locking mechanisms beyond synchronized, including ReentrantLock, ReadWriteLock, StampedLock, and Condition for flexible thread coordination. This lesson covers explicit lock acquisition, fairness, lock ordering, and condition-based waiting.

Java Record Class — Complete Guide

Learn Java record classes from Java 14 for creating transparent data carriers with auto-generated constructors, accessors, equals, and hashCode methods.

Executors — Thread Pools, ScheduledExecutorService, invokeAll, and invokeAny

Java's ExecutorService framework decouples task submission from execution, providing thread pools that manage worker threads efficiently. This lesson covers thread pool types, ScheduledExecutorService for delayed/periodic tasks, invokeAll for batch processing, and invokeAny for first-result semantics.

Java Sealed Class — Complete Guide

Learn Java sealed classes that restrict subclassing to a set of permitted types, enabling exhaustive pattern matching and more controlled class hierarchies.

Concurrent Collections — ConcurrentHashMap, CopyOnWriteArrayList, and BlockingQueue

Java's java.util.concurrent package provides thread-safe collections optimized for high-concurrency scenarios. This lesson covers ConcurrentHashMap for concurrent maps, CopyOnWriteArrayList for read-heavy lists, and BlockingQueue implementations for producer-consumer patterns.

Java Pattern Matching Switch — Complete Guide

Learn Java pattern matching for switch expressions, allowing type checks and deconstruction directly in case labels for cleaner, more expressive branching.

Fork-Join Framework — RecursiveTask, RecursiveAction, Work Stealing, and Parallel Arrays

Java's Fork-Join framework implements the divide-and-conquer algorithm pattern with efficient work-stealing thread pools. This lesson covers RecursiveTask for tasks with results, RecursiveAction for void tasks, the work-stealing algorithm, and parallel processing of arrays.

Java Text Blocks — Complete Guide

Learn Java text blocks for multiline string literals with automatic formatting, eliminating escape sequences and improving readability of SQL, JSON, and HTML.

Virtual Threads (Project Loom) — Complete Guide

Learn about virtual threads in Java 21, how they differ from platform threads, and why they revolutionize concurrency with lightweight, scalable threading.

Java Foreign Function and Memory API

Learn the Java Foreign Function and Memory API for safely calling native libraries and managing off-heap memory without the fragility of JNI boilerplate.

Java Platform Module System — Complete Guide

Understand Java modules introduced in Java 9, how to define module-info.java, export packages, require dependencies, and create modular applications with JPMS.

Java Vector API — Complete Guide

Learn the Java Vector API for expressing data-parallel computations that reliably compile to SIMD instructions across different CPU architectures at runtime.

JVM Architecture and Performance Tuning

Explore JVM internals including class loader subsystem, runtime data areas, garbage collection algorithms, JIT compilation, and tuning flags for optimal performance.

Java Structured Concurrency — Complete Guide

Learn Java structured concurrency for managing multiple tasks as a single unit of work, improving error handling and observability in concurrent programs.

Java Version Features (8 through 21)

Survey major language features from Java 8 lambdas through Java 21 pattern matching, virtual threads, and sequenced collections in a comprehensive timeline.

JDBC and Database Connectivity — Complete Guide

Connect Java applications to relational databases using JDBC, execute SQL queries, manage transactions, and work with connection pools effectively for data persistence.

Servlets and JSP — Complete Guide

Build web applications with Java Servlets and JavaServer Pages, handling HTTP requests and responses, session management, and the MVC architecture pattern.

Spring Boot Basics — Complete Guide

Get started with Spring Boot, auto-configuration, dependency injection, REST controllers, and building production-ready microservices with minimal setup.

Spring Data JPA — Complete Guide

Simplify database access with Spring Data JPA, define repositories, entity mappings, JPQL queries, and integrate with Hibernate ORM for seamless data persistence.

Building REST APIs with Spring

Design and implement RESTful web services using Spring Boot, handling JSON serialization, validation, error handling, security, and OpenAPI documentation.

Microservices Architecture with Java — Complete Guide

Learn microservices design patterns, service discovery, API gateways, inter-service communication, containerization with Docker, and deployment strategies for Java.

Mini Project 1 - E-Commerce Backend

Build a complete e-commerce backend REST API with Spring Boot, Spring Data JPA, and PostgreSQL covering products, orders, users, and payment integration.

Mini Project 2 - Real-Time Chat Application

Develop a real-time chat application using WebSockets, Spring Boot, and STOMP protocol with features like chat rooms, private messaging, and typing indicators.

Design Patterns in Java — Complete Guide

Master creational, structural, and behavioral design patterns with practical Java implementations, including Singleton, Factory, Observer, Strategy, and Decorator.

Java Interview Preparation — Complete Guide

Comprehensive Java interview prep covering core concepts, OOP, collections, concurrency, JVM, Spring Boot, microservices, and system design with sample questions.