Skip to content
Tutorials Center
My learning

Topics

Java Tutorial

Learn Java from your first program to collections, streams, concurrency, networking and the JVM. 201 lessons with real Java 25 running in your browser, quizzes and projects.

Start learning →

of lessons completed

Getting Started

  1. 1 Getting Started with Java Learn what Java is, where it runs today and how to write your first Java 25 program, in both the short modern form and the classic public class Main style.
  2. 2 How Java Works: JDK, JVM and Bytecode Follow a Java program from source code to bytecode to the JVM. Learn what the JDK, JRE and JIT compiler are, which LTS version to install and how to run Java files.
  3. 3 Java Syntax Learn the basic rules of Java syntax - statements and semicolons, blocks and braces, classes and methods, case sensitivity, naming conventions and reading compiler errors.
  4. 4 Comments and Javadoc Learn Java's comment styles - // and /* */, Javadoc with @param and @return, Markdown doc comments with /// (Java 23+) - and the habits that make comments useful.
  5. 5 Printing Output Print output in Java with System.out.println, print and IO.println, use escape sequences like \n and \t, format numbers with printf, and send errors to System.err.
  6. 6 Reading User Input Read keyboard input in Java with Scanner, IO.readln (Java 25) and BufferedReader. Parse numbers safely, avoid the nextInt + nextLine trap and loop over all input.
  7. 7 Java Keywords and Identifiers See every reserved Java keyword grouped by purpose, the contextual keywords like var, record, sealed and yield, the literals true, false and null, and the rules for identifiers.
  8. 8 JShell: the Java REPL Learn JShell, Java's built-in REPL. Type expressions, declare variables and methods, use commands like /vars and /list, and drive JShell from your own code.

Variables and Types

  1. 9 Variables Learn how Java variables work - declaring them with a type, initializing and reassigning values, naming them well, definite assignment rules and a first look at scope.
  2. 10 Primitive Data Types Learn Java's eight primitive types, their sizes, ranges and default values, how to write int, long, float and hex or binary literals, and how primitives differ from references.
  3. 11 Working with Numbers Understand how Java numbers really behave - integer division and remainder, silent overflow and Math.addExact, floating-point precision, NaN, Infinity and when to use BigDecimal.
  4. 12 Characters and Booleans Learn how Java's char stores UTF-16 code units, do arithmetic with characters, use Character methods, handle emoji and code points, and write clear boolean expressions.
  5. 13 Type Casting and Conversion Learn Java type casting - automatic widening, narrowing casts and data loss, rounding vs truncating, converting int to String and back, and handling NumberFormatException.
  6. 14 Local Variable Type Inference with var Learn how Java's var keyword infers local variable types, where it is allowed and forbidden, what type it really picks, and when var makes code clearer or harder to read.
  7. 15 Constants and final Learn to create constants in Java with final and static final, name them in UPPER_SNAKE_CASE, avoid magic numbers, and understand effectively final variables and lambdas.
  8. 16 The Math Class Master Java's Math class - abs, pow, sqrt, hypot, max and min, round vs floor vs ceil, clamp, floorDiv and floorMod, trigonometry, and Math.random vs Random vs RandomGenerator.

Operators

  1. 17 Arithmetic Operators Learn Java's arithmetic operators, unary minus, string concatenation with +, integer vs floating-point division, operator precedence and the numeric promotion rules behind every result.
  2. 18 Assignment and Increment Operators Learn Java's = and compound assignment operators, the hidden cast inside +=, prefix vs postfix ++ and --, and the classic puzzles that trip up developers.
  3. 19 Comparison and Logical Operators Compare values in Java with ==, !=, <, >, <= and >=, combine conditions with &&, || and !, understand short-circuiting, and see why objects need equals().
  4. 20 Bitwise and Shift Operators Learn Java's bitwise operators & | ^ ~ and the shifts << >> >>>, how two's complement works, and how to use flags, masks and Integer bit helpers.
  5. 21 Operator Precedence and the Ternary Operator See Java's full operator precedence table, how associativity and left-to-right evaluation work, and how to use the ?: ternary operator and instanceof safely.

Strings

  1. 22 Strings Learn how Java strings work, from literals, length and charAt to immutability, equals vs ==, the string pool, intern, compareTo, isEmpty and isBlank.
  2. 23 String Methods A practical tour of Java String methods - substring, indexOf, contains, replace vs replaceAll, split, join, strip, repeat, chars and lines - with their pitfalls.
  3. 24 Formatting Strings Format text in Java with String.format, formatted() and printf - width, flags, precision, argument indexes, dates - plus NumberFormat and Locale for any country.
  4. 25 Text Blocks and Escape Sequences Write multi-line strings with Java text blocks - indentation rules, the closing delimiter, \ and \s escapes - plus every escape sequence and JSON, SQL and HTML examples.
  5. 26 StringBuilder Learn Java's StringBuilder - why += in a loop is slow, how append, insert, delete, replace and reverse work, capacity, chaining and the pitfalls to avoid.
  6. 27 StringBuffer, StringJoiner and StringTokenizer Compare StringBuffer and StringBuilder, join text with StringJoiner, String.join and Collectors.joining, and replace legacy StringTokenizer with split.
  7. 28 Comparing and Converting Strings Compare Java strings with equals, equalsIgnoreCase, compareTo and Collator, and convert between strings, numbers, char arrays and byte arrays safely.

Control Flow

  1. 29 if, else if and else Make decisions in Java with if, else if and else - boolean conditions, nesting, guard clauses, brace style and classic bugs like = vs == and the dangling else.
  2. 30 switch Statements and Expressions Master Java switch - classic case and break, fall-through, arrow labels, switch expressions with yield, strings, enums, null handling and exhaustiveness.
  3. 31 while and do-while Loops Repeat code in Java with while and do-while loops - counters, sentinel values, input loops, infinite loops with break, and the bugs that make loops never stop.
  4. 32 for Loops Learn Java for loops - the classic counting loop, for-each over arrays and lists, nested loops, multiple loop variables, loop variable scope and off-by-one bugs.
  5. 33 break, continue and Labels Control Java loops with break and continue, exit nested loops with labeled break, skip with labeled continue, return from loops, and avoid the classic traps.

Arrays

  1. 34 Arrays Learn Java arrays - declaring and creating them, indexes and length, default values, array literals, ArrayIndexOutOfBoundsException and why arrays are objects.
  2. 35 Looping Through Arrays Loop through Java arrays with for and for-each - sum, max, min and average, searching, counting, reversing in place, modifying elements and copying arrays safely.
  3. 36 Multidimensional Arrays Learn Java multidimensional arrays - creating 2D arrays, rows and columns, jagged arrays, nested loops over grids, printing with deepToString and matrix multiplication.
  4. 37 The Arrays Class Master java.util.Arrays - toString, sort with comparators, binarySearch, fill, setAll, copyOf, equals and deepEquals, asList pitfalls, stream, mismatch and compare.

Methods

  1. 38 Methods Learn Java methods - why they matter, how to define and call them, static methods, void methods, return in brief, naming conventions and how to split a program into methods.
  2. 39 Parameters and Return Values Pass data into Java methods and get results back - parameters vs arguments, return rules, why Java is always pass-by-value, and returning several values with records.
  3. 40 Method Overloading Learn Java method overloading - the rules, how the compiler picks an overload through widening, boxing and varargs, ambiguous calls, and the list.remove(int) trap.
  4. 41 Variable Scope Understand Java variable scope - block and method scope, loop variables, fields vs local variables, shadowing with this, pattern variable scope and how long variables live.
  5. 42 Recursion Learn recursion in Java - base cases, how the call stack works, factorial, Fibonacci, power and sums, StackOverflowError, recursion vs loops and memoization.
  6. 43 Variable Arguments (Varargs) Learn Java varargs - the Type... syntax, how arguments become an array, the rules, null and empty calls, overloading pitfalls, and how String.format and List.of use them.
  7. 44 The main Method and Command-Line Arguments Understand every word of public static void main(String[] args), Java 25 instance main methods, reading and parsing command-line arguments, and exit codes with System.exit.
  8. 45 Static vs Instance Methods Learn the difference between static and instance methods in Java, the calling rules, the "non-static method cannot be referenced" error, utility classes and how to choose.

Object-Oriented Programming

  1. 46 Object-Oriented Programming Learn what object-oriented programming means in Java - classes vs objects, state and behavior, encapsulation, inheritance, polymorphism, abstraction and how OOP compares to procedural code.
  2. 47 Classes and Objects Learn to define Java classes, create objects with new, understand references and aliasing, null and NullPointerException, several classes in one file and objects in memory.
  3. 48 Fields and Instance Methods Learn Java instance fields, their default values and initializers, instance methods that read and change object state, accessing members, and when to use fields vs local variables.
  4. 49 Constructors Learn Java constructors - default and parameterized constructors, overloading, this(...) chaining, validating arguments, initialization order, Java 25 flexible bodies and copy constructors.
  5. 50 The this Keyword Learn what this means in Java - telling fields from parameters, the self-assignment bug, passing this to other objects, fluent APIs, this(...) and lambdas.
  6. 51 Access Modifiers Learn Java's access modifiers - public, protected, package-private and private - with a clear table, class-level privacy, private constructors and practical rules.
  7. 52 Encapsulation, Getters and Setters Learn encapsulation in Java - private fields, getters and setters done right, protecting invariants, hiding the representation and making defensive copies.
  8. 53 Immutable Classes Learn how to write immutable classes in Java - final fields, no setters, defensive copies, with-methods - why they're safer for maps and threads, and records.
  9. 54 Static Fields, Methods and Blocks Learn Java static members - shared fields and counters, static methods, utility classes, static and instance initializer blocks, and the exact initialization order.
  10. 55 Inheritance Learn Java inheritance - extends and is-a, what subclasses inherit, constructor chaining, protected, single inheritance, final classes and Object as the root.
  11. 56 The super Keyword Learn Java's super keyword - calling parent constructors, extending overridden methods, reaching hidden fields, constructor order and the Java 25 prologue.
  12. 57 Polymorphism and Method Overriding Learn Java polymorphism - method overriding with @Override, dynamic dispatch, overriding rules, overloading vs overriding, upcasting, downcasting and instanceof.
  13. 58 Abstraction and Abstract Classes Learn abstraction in Java - abstract classes and methods, the rules the compiler enforces, constructors in abstract classes and the template method pattern.
  14. 59 Interfaces Learn Java interfaces - implementing one or many, default, static and private methods, constants, marker interfaces, and when to pick an interface over an abstract class.
  15. 60 Composition, Aggregation and Association Learn has-a relationships in Java - association, aggregation and composition, why to favor composition over inheritance, and how delegation keeps classes flexible.
  16. 61 Records Learn Java records - what the compiler generates, compact constructors for validation, shallow immutability, static factories, local records and when to use them.
  17. 62 Enums Learn Java enums - named constants, values() and valueOf, fields and constructors, constant-specific methods, switch expressions, EnumSet and EnumMap.
  18. 63 Nested, Inner, Local and Anonymous Classes Learn the four kinds of Java nested classes - static nested, inner, local and anonymous - how they access outer members, when to use each, and the memory pitfall.
  19. 64 The Object Class: equals, hashCode and toString Learn the Object class in Java - overriding equals and hashCode correctly, the contract between them, useful toString, getClass, and the Objects helper methods.
  20. 65 Copying Objects: Cloning and Copy Constructors Learn how to copy objects in Java - reference copies, shallow vs deep copies, Cloneable and clone() pitfalls, copying arrays, and why copy constructors are preferred.
  21. 66 Sealed Classes and Interfaces Learn Java sealed classes and interfaces - sealed, permits, final and non-sealed subclasses, records as subtypes, exhaustive switches and modeling closed hierarchies.
  22. 67 Pattern Matching Learn Java pattern matching - instanceof patterns, switch with type patterns, case null, guards with when, nested record patterns, exhaustive sealed switches and unnamed _.
  23. 68 The final Keyword Everywhere Learn every use of Java final - local variables, parameters, fields, methods and classes, blank finals, effectively final, illegal combinations and final vs immutable.
  24. 69 Packages and Imports Learn Java packages and imports - package names and folders, single-type and on-demand imports, name clashes, static import, import module (Java 25) and the classpath.
  25. 70 JavaBeans and Property Change Events Learn the JavaBeans conventions, bound and constrained properties with PropertyChangeSupport and VetoableChangeSupport, and how Introspector finds properties.

Exceptions

  1. 71 Exceptions and try-catch Learn Java exceptions - how they propagate, reading stack traces, try-catch-finally, multiple catch blocks, multi-catch, errors vs exceptions and the common built-in exceptions.
  2. 72 Throwing Exceptions: throw and throws Learn to throw exceptions in Java - the throw statement, the throws clause, checked vs unchecked exceptions, the Throwable hierarchy, choosing exception types and rethrowing.
  3. 73 Custom Exceptions Learn to create custom exceptions in Java - checked or unchecked, the standard constructors, extra fields, exception hierarchies, chaining causes and exception translation.
  4. 74 try-with-resources Learn Java try-with-resources - AutoCloseable and Closeable, closing order, multiple resources, suppressed exceptions, failures while opening and writing your own resources.
  5. 75 Exception Handling Best Practices Handle Java exceptions like a professional - never swallow them, catch specific types, fail fast, avoid finally traps, choose Optional or exceptions, log once.
  6. 76 Debugging Java Programs Learn to debug Java - read stack traces and Caused by chains, use helpful NullPointerException messages, print debugging, assertions, debuggers and common bugs.
  7. 77 Stack Traces and Exception Chaining Read Java stack traces line by line, chain exceptions with a cause, handle suppressed exceptions, use StackWalker and learn what each Caused by and "... n more" line really means.

Collections

  1. 78 Wrapper Classes and Autoboxing Learn Java wrapper classes - Integer, Double, Boolean and friends, autoboxing and unboxing, valueOf vs parseInt, the Integer cache, == pitfalls and null NPEs.
  2. 79 The Collections Framework A map of the Java Collections Framework - Collection, List, Set, Queue, Deque, Map and sequenced collections, the main implementations and how to choose one.
  3. 80 ArrayList Master Java ArrayList - add, get, set and remove, searching, safe removal while iterating, removeIf, subList views, sorting, capacity growth and performance.
  4. 81 LinkedList Learn Java LinkedList - List and Deque methods, how its doubly linked nodes work, the get(i) trap, when it really helps, and an ArrayList vs LinkedList benchmark.
  5. 82 HashMap Learn Java HashMap - put, get, getOrDefault and putIfAbsent, iterating entries, merge, compute and computeIfAbsent, plus counting and grouping recipes.
  6. 83 How HashMap Works Inside See how Java HashMap works inside - hash codes, buckets, collisions, load factor and resizing, treeified bins, why mutable keys break maps and what makes a good hashCode.
  7. 84 HashSet Learn Java HashSet - storing unique values, add/contains/remove, union, intersection and difference, iteration order, and why equals and hashCode matter.
  8. 85 LinkedHashMap and LinkedHashSet Learn Java LinkedHashMap and LinkedHashSet - predictable insertion order, access order, an LRU cache with removeEldestEntry, and the Java 21 sequenced methods.
  9. 86 TreeMap and TreeSet Learn Java TreeMap and TreeSet - sorted keys, first/last, floor/ceiling/higher/lower, headMap, tailMap and subMap ranges, NavigableMap and custom comparators.
  10. 87 Iterators and ListIterator Learn Java iterators - hasNext, next and remove, ListIterator for both directions, why ConcurrentModificationException happens, and how to implement Iterable.
  11. 88 Queues, Deques and PriorityQueue Learn Java queues - offer, poll and peek, ArrayDeque as a stack and a queue, PriorityQueue with comparators, top-k problems, and the mistakes to avoid.
  12. 89 Sorting with Comparable and Comparator Learn to sort in Java - the compareTo contract, Comparable natural order, Comparator.comparing, thenComparing, reversed, nullsFirst, List.sort and stable sorting.
  13. 90 Immutable Collections and Utility Methods Learn Java immutable collections - List.of, Set.of, Map.of, copyOf, unmodifiable views, the Collections helper methods and Java 21 sequenced getFirst, getLast and reversed.
  14. 91 Building Custom Collections with AbstractList and AbstractMap Build your own Java collections the easy way. Extend AbstractList, AbstractSequentialList and AbstractMap, implement a few methods, and inherit the rest of the List and Map API.
  15. 92 EnumMap, EnumSet, IdentityHashMap, WeakHashMap and BitSet Learn the specialized Java collections - EnumMap and EnumSet for enum keys, IdentityHashMap for reference equality, WeakHashMap for GC-friendly maps and BitSet for flags.
  16. 93 Legacy Collections: Vector, Stack, Hashtable and Enumeration Learn what Java's legacy collections Vector, Stack, Hashtable and Enumeration do, why they are outdated, and which modern classes replace them in new code.
  17. 94 Choosing the Right Collection Pick the right Java collection every time with a step-by-step decision guide, a Big-O table for common operations, memory notes and simple timing with System.nanoTime.

Generics and Functional Programming

  1. 95 Generics Learn Java generics - why they exist, writing generic classes, interfaces and methods, type inference and the diamond operator, invariance, and why raw types are unsafe.
  2. 96 Bounded Types and Wildcards Learn Java bounded type parameters and wildcards - T extends, multiple bounds, ? extends and ? super, the PECS rule, unbounded ?, and when to use a wildcard or a type parameter.
  3. 97 Type Erasure and Generic Limitations Learn how Java type erasure works, why new T(), generic arrays, primitives and instanceof List<String> aren't allowed, the workarounds, heap pollution and @SafeVarargs.
  4. 98 Lambda Expressions Learn Java lambda expressions - syntax forms, target typing, capturing effectively final variables, this in lambdas, and using lambdas with forEach, removeIf, sort and replaceAll.
  5. 99 Functional Interfaces Learn Java functional interfaces - Function, Predicate, Consumer, Supplier, BiFunction, operators, primitive versions, composing with andThen and negate, and @FunctionalInterface.
  6. 100 Method References Learn Java method references - static, bound and unbound instance, and constructor references, how they map to lambdas, when receivers are evaluated, and when a lambda reads better.
  7. 101 Streams Learn Java streams - creating them, filter/map/sorted/distinct/limit/skip, terminal operations, laziness, short-circuiting and IntStream ranges, with runnable examples.
  8. 102 Collecting Stream Results Learn Java stream collectors - toList, toSet, toMap with merge functions, groupingBy with downstream collectors, partitioningBy, joining, summarizing and reduce.
  9. 103 Advanced Streams Go beyond stream basics - flatMap and mapMulti, takeWhile/dropWhile, infinite streams, parallel streams and when to avoid them, Java 24 gatherers and common mistakes.
  10. 104 Optional Learn Java Optional - creating it with of/empty/ofNullable, map, flatMap and filter, orElse vs orElseGet, orElseThrow, ifPresentOrElse and when not to use Optional.
  11. 105 Functional Programming in Java Learn functional programming in Java - pure functions, immutability, higher-order functions, currying and partial application, composition, laziness, and recursion vs streams.

Working with Data

  1. 106 Dates and Times Learn the java.time API - LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Instant, Duration, Period, TemporalAdjusters and DateTimeFormatter, plus why to avoid Date.
  2. 107 Regular Expressions Learn Java regular expressions - regex syntax, Pattern and Matcher, matches vs find, capturing and named groups, flags, replaceAll with functions, split and performance tips.
  3. 108 BigInteger and BigDecimal Learn BigInteger for integers of any size and BigDecimal for exact decimal and money math - creating values, scale and precision, rounding modes, division and compareTo vs equals.
  4. 109 Random Numbers Generate random numbers in Java with Random, ThreadLocalRandom and RandomGenerator, make results repeatable with seeds, use SecureRandom for tokens, and shuffle and sample.
  5. 110 UUIDs, Hashing and Base64 Create UUIDs in Java, hash data with MessageDigest and SHA-256, print bytes with HexFormat, encode with Base64, verify with HMAC and compute CRC32 checksums.
  6. 111 Locales and Internationalization Format numbers, currencies, percentages and dates for any country with Java's Locale, load translations with ResourceBundle, and avoid the Turkish i and other locale bugs.
  7. 112 Time Zones and Daylight Saving Handle time zones in Java correctly - ZoneId vs ZoneOffset, ZonedDateTime, Instant, DST gaps and overlaps, and the mistakes that break scheduling code.

Input and Output

  1. 113 Reading and Writing Files Read and write files in Java with Path and Files - writeString, readString, readAllLines, lines, append, copy, move, delete - plus error handling and safe, atomic writes.
  2. 114 Byte and Character Streams Understand Java I/O streams - InputStream and OutputStream for bytes, Reader and Writer for text, buffering, PrintWriter, InputStreamReader and closing with try-with-resources.
  3. 115 Reader and Writer Classes in Depth A tour of Java's character streams - the Reader and Writer methods, StringReader, CharArrayReader and Writer, FilterReader, InputStreamReader, PipedReader, FileReader and PrintWriter.
  4. 116 Working with Directories Work with folders in Java - create directories, list them with Files.list and DirectoryStream globs, walk and search trees, read file attributes, use temp folders and delete trees.
  5. 117 Serialization Learn Java serialization - Serializable, ObjectOutputStream and ObjectInputStream, transient fields, serialVersionUID, custom writeObject, records, filters and safer alternatives.
  6. 118 Character Sets and Encoding Understand bytes vs characters in Java - Unicode, UTF-8 and UTF-16, StandardCharsets, getBytes and new String, mojibake, BOMs, malformed input and the UTF-8 default.
  7. 119 Properties Files and Configuration Learn Java configuration - load and store .properties files with java.util.Properties, defaults, system properties with -D, environment variables and Preferences.
  8. 120 Compressing Data with GZIP and ZIP Compress data in Java with GZIPOutputStream and GZIPInputStream, build and read ZIP archives, verify data with CRC32, and avoid zip slip and zip bombs.
  9. 121 Image Processing in Java Read and write images with ImageIO, get and set pixels in a BufferedImage, and build grayscale, negative, sepia, color-channel, random and mirror filters in plain Java.
  10. 122 Scanner Patterns and Pitfalls Master Java's Scanner - token versus line reading, custom delimiters, the newline trap, hasNext loops, regex methods, locales and when to choose BufferedReader instead.
  11. 123 NIO.2: Path, Files and WatchService Learn Java NIO.2 - Path operations like resolve and relativize, Files copy and move options, atomic moves, zip file systems and WatchService for reacting to folder changes.
  12. 124 Running External Processes Learn how to run external programs from Java with ProcessBuilder - read output, feed input, merge stderr, check exit codes, set timeouts, environment variables and avoid deadlocks.

Concurrency

  1. 125 Threads Learn Java threads - processes vs threads, creating threads with Thread and Runnable, start vs run, join, sleep, thread names, daemon threads and thread exceptions.
  2. 126 Thread Lifecycle and Priorities Learn the Java thread lifecycle - NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING and TERMINATED with getState demos, thread priorities and how to interrupt threads.
  3. 127 Synchronization and Race Conditions Understand race conditions in Java and fix them with synchronized methods and blocks, intrinsic locks, volatile and the happens-before rules, with runnable demos.
  4. 128 Inter-Thread Communication: wait and notify Learn how Java threads cooperate with wait, notify and notifyAll - the guarded-block pattern, a producer-consumer buffer, spurious wakeups and common mistakes.
  5. 129 Deadlocks, Livelocks and Starvation See a Java deadlock happen and time out safely with tryLock, detect deadlocks with ThreadMXBean, prevent them with lock ordering, and avoid livelock and starvation.
  6. 130 Locks and Conditions Learn the java.util.concurrent.locks API - ReentrantLock, tryLock with timeouts, lockInterruptibly, ReadWriteLock, Condition, StampedLock and when to prefer synchronized.
  7. 131 Atomic Variables Learn Java atomic variables - AtomicInteger, AtomicLong, AtomicReference and AtomicBoolean, compareAndSet loops, LongAdder, and when atomics beat locks.
  8. 132 Executors and Thread Pools Learn Java executors - ExecutorService, fixed, cached and scheduled thread pools, Callable and Future, invokeAll and invokeAny, and how to shut a pool down properly.
  9. 133 CompletableFuture Learn Java CompletableFuture - supplyAsync, thenApply, thenCompose and thenCombine, allOf and anyOf, exceptionally and handle, and timeouts with orTimeout.
  10. 134 CountDownLatch, CyclicBarrier, Semaphore and Phaser Learn Java synchronizers - CountDownLatch to wait for events, CyclicBarrier for rounds, Semaphore to limit access, and Phaser for flexible multi-phase work.
  11. 135 Concurrent Collections Learn Java concurrent collections - ConcurrentHashMap with atomic merge and compute, CopyOnWriteArrayList, BlockingQueue producer-consumer, and ConcurrentLinkedQueue.
  12. 136 The Fork/Join Framework Learn the Java Fork/Join framework - RecursiveTask and RecursiveAction, divide-and-conquer sums and sorts, thresholds, work stealing, and how parallel streams use it.
  13. 137 Virtual Threads and Structured Concurrency Learn Java virtual threads - how they differ from platform threads, newVirtualThreadPerTaskExecutor, pinning, scoped values, and structured concurrency with StructuredTaskScope.
  14. 138 ThreadLocal and ScopedValue Learn Java ThreadLocal for per-thread state, why it leaks in thread pools, how InheritableThreadLocal behaves, and how ScopedValue (final in Java 25) replaces it safely.
  15. 139 Timer and ScheduledExecutorService Schedule delayed and repeating tasks in Java with Timer and ScheduledExecutorService - fixed rate versus fixed delay, cancelling, error handling and clean shutdown.

Networking

  1. 140 Networking Basics Learn the networking basics every Java developer needs - IP addresses, ports, TCP vs UDP, DNS, InetAddress, parsing URIs and URLs, and talking to 127.0.0.1.
  2. 141 TCP Sockets Learn Java TCP socket programming - ServerSocket and Socket, an echo server and client, reading and writing over streams, timeouts, many clients and closing properly.
  3. 142 UDP with DatagramSocket Learn UDP in Java with DatagramSocket and DatagramPacket - sending and receiving packets, replies, timeouts, lost packets, retries and when UDP beats TCP.
  4. 143 The Java HTTP Client Learn the java.net.http HttpClient - GET and POST requests, headers, status codes, body handlers, async calls, timeouts and redirects, tested against a local HttpServer.
  5. 144 Remote Method Invocation (RMI) Learn Java RMI - remote interfaces, exporting objects, the registry, stubs, serialized arguments, remote exceptions and callbacks - with a loopback demo you can run.

Desktop GUI

  1. 145 Java GUI Overview: AWT, Swing and JavaFX Compare Java's desktop GUI toolkits - AWT, Swing and JavaFX - their history and design, where desktop Java is used today, headless mode and how to run GUI code locally.
  2. 146 Swing Basics Learn Swing basics - JFrame, JPanel, JLabel, JButton and JTextField, the BorderLayout, FlowLayout and GridLayout managers, nesting panels and the event dispatch thread.
  3. 147 Swing Layout Managers Go beyond the basics with Swing layout managers - BoxLayout alignment and glue, GridBagLayout constraints and weights, CardLayout decks and when to nest panels.
  4. 148 Swing Events and a Small App Handle Swing events with ActionListener lambdas, Actions and document listeners, build a temperature converter app and keep it responsive with SwingWorker.
  5. 149 Swing Components - Tables, Lists, Trees and Dialogs Learn the Swing data components JTable, JList, JComboBox and JTree, how their models work, plus JOptionPane dialogs and menus, with runnable model examples.
  6. 150 JavaFX Introduction Get started with JavaFX - Application, Stage, Scene and nodes, layout panes, event handlers, properties and binding, FXML and CSS, and how to set up OpenJFX.

JVM and Advanced Topics

  1. 151 Memory and Garbage Collection Understand Java memory - stack vs heap, references and reachability, generational garbage collection, G1 and ZGC, memory leaks, Runtime stats and soft and weak references.
  2. 152 Soft, Weak and Phantom References Learn Java reference types - strong, soft, weak and phantom references, ReferenceQueue, WeakHashMap and Cleaner - with runnable examples and cache guidance.
  3. 153 JVM Architecture and Class Loading How the JVM works inside - class loaders and delegation, loading, linking and initialization, the runtime data areas, bytecode you can read, and JIT tiers.
  4. 154 Annotations Learn Java annotations - @Override, @Deprecated and friends, defining your own, retention and targets, repeatable and inherited annotations, and reading them at run time.
  5. 155 Reflection Learn Java reflection - Class objects, inspecting and changing fields, invoking methods, creating instances, setAccessible and modules, proxies and method handles.
  6. 156 The Java Module System (JPMS) Learn the Java Platform Module System - module-info.java, requires, exports, opens and services, strong encapsulation, the module path, and custom runtimes with jlink.
  7. 157 ServiceLoader and the Service Provider Pattern Learn how Java's ServiceLoader finds plugins at run time, how to register providers with META-INF/services, lazy streams, error handling and design tips.
  8. 158 Object-Oriented Design Principles (SOLID) Learn the SOLID principles in Java - single responsibility, open/closed, Liskov substitution, interface segregation and dependency inversion - with runnable before/after code.
  9. 159 Creational Design Patterns Learn creational design patterns in Java - singleton (enum and lazy holder), static factories, factory method, abstract factory, builder and prototype - with runnable code.
  10. 160 Structural and Behavioral Design Patterns Learn the essential structural and behavioral design patterns in Java - adapter, decorator, facade, proxy, composite, strategy, observer, command, iterator, template method, state.
  11. 161 Unit Testing with JUnit Learn unit testing in Java with JUnit - why tests matter, @Test methods, assertions, the Arrange-Act-Assert pattern, reading failures and writing good tests.
  12. 162 Build Tools: Maven and Gradle Learn why Java projects use build tools, the standard project layout, dependencies, pom.xml and build.gradle.kts basics, and how JAR files and the classpath work.
  13. 163 Logging Learn Java logging - why println isn't enough, java.util.logging loggers, levels, handlers, formatters and config files, System.Logger and an SLF4J overview.
  14. 164 Java Performance Tips Make Java code faster the right way - measure with nanoTime and JMH, avoid boxing and string concatenation in loops, pick the right collection, cache and profile.
  15. 165 Best Practices and Common Mistakes Avoid the Java mistakes that compile but break programs - == on objects, equals without hashCode, null leaks, mutable state, money in double, resource leaks and more.
  16. 166 Java Versions and History A guided tour of Java's history from 1.0 to Java 25 - LTS releases, the six-month cadence, headline features of each version, preview features and Runtime.version().
  17. 167 Secure Coding in Java Write safer Java. Validate input with allow-lists, stop path traversal and SQL injection, use SecureRandom, hash passwords with PBKDF2, filter deserialization.
  18. 168 Native Code: JNI and the Foreign Function API Call C libraries from Java. Compare the old JNI with the modern Foreign Function and Memory API: Linker, Arena, MemorySegment, downcalls and upcalls.
  19. 169 JVM Options and GC Tuning Learn the JVM flags that matter: heap sizing with -Xms and -Xmx, container settings, choosing G1, ZGC, Parallel or Serial, GC logs, OOM handling and JFR.
  20. 170 Profiling with JFR and VisualVM Record with Java Flight Recorder, read hot methods, write custom JFR events, take heap dumps and use VisualVM.
  21. 171 Benchmarking with JMH Measure small pieces of Java code correctly. Learn why naive timing fails, then use JMH with @Benchmark, @State, @Param, Blackhole, forks and warm-up.

Projects

  1. 172 Project: Number Guessing Game Build a number guessing game in Java step by step - Random with a seed, an input loop, hints, attempt limits, difficulty levels, replays and a computer that guesses.
  2. 173 Project: Grade Book Build a Java grade book step by step. Read scores from input, validate them, compute weighted averages and letter grades, and print a neat class report.
  3. 174 Project: Bank Account System Build a Java bank account system in stages with encapsulation, BigDecimal money, custom exceptions, checking and savings subclasses and a transaction history.
  4. 175 Project: Library Management System Build a Java library system in stages - books, members and loans with records and maps, due dates and fines with java.time, search, reports and text commands.
  5. 176 Project: Inventory Manager Build a Java inventory manager in stages. Parse CSV data into validated records, store products in a map, update stock immutably and build stream reports.
  6. 177 Project: Text Analyzer Build a Java text analyzer in stages. Count words and sentences with regular expressions, rank word frequencies with HashMap and streams, and print a full report.
  7. 178 Project: Tic-Tac-Toe Build Tic-Tac-Toe in Java step by step - a 2D array board, enums for players, moves from input, win and draw detection, and a computer opponent you can beat.
  8. 179 Project: Employee Management System Build an employee management system in Java - records, a repository interface, CRUD commands from input, stream reports and file persistence that survives a restart.
  9. 180 Project: Snake Game Build the Snake game in Java - a testable game model with a deque, tick logic and collisions, buffered key presses, a BFS autopilot and a Swing window.
  10. 181 Project: A Swing Text Editor Build a text editor in Java - a document model with undo and redo, find and replace with regex, safe open and save with NIO, and a Swing window with menus.
  11. 182 Project: Multi-Client Chat Server Build a multi-client chat server in Java with ServerSocket and a virtual thread per client - nicknames, private messages, commands, broadcasting and clean shutdown.
  12. 183 Project: ATM Simulation Build a Java ATM simulator with a hashed PIN check and lockout, BigDecimal balances, per-transaction and daily withdrawal limits, note dispensing and a transaction log.
  13. 184 Project: Currency Converter Build a Java currency converter with an exchange-rate map, cross rates through a base currency, BigDecimal rounding by currency, fees and Locale-aware money formatting.
  14. 185 Project: Scientific Calculator Build a Java scientific calculator that parses expressions like sin(pi / 2) + 2 ^ 3 with a tokenizer, the shunting-yard algorithm, sealed token types and Math functions.
  15. 186 Project: Memory Card Game Build a Java memory matching game with a testable game-state model, bots that prove the rules work, and a Swing grid view with javax.swing.Timer for flipping and the clock.
  16. 187 Project: A Simple Search Engine Build a small Java search engine with a tokenizer, an inverted index, term frequency and TF-IDF ranking, prefix and exclusion queries, highlighted snippets and live add and remove.
  17. 188 Project: Sudoku Solver Build a Java Sudoku validator and solver with backtracking, then speed it up with bitmasks and the fewest-candidates rule, count solutions and generate puzzles with one answer.
  18. 189 Project: Supermarket Billing System Build a Java supermarket billing system with a product catalog, a cart, sealed discount rules, tax on taxable items and an aligned receipt, all with exact BigDecimal money.
  19. 190 Project: Word Counter Build a Java word counter step by step. Tokenize text with a regex, count with Collectors.groupingBy, sort a top-N report, read files and stdin, and write a small CLI.

Data Structures and Algorithms

  1. 191 Data Structures in Java Implement a dynamic array, stack, queue, singly linked list and binary search tree in Java with generics, then learn when to use the built-in collections.
  2. 192 Searching and Sorting Algorithms Implement linear and binary search plus bubble, selection, insertion, merge, quick and heap sort in Java, with step-by-step traces, Big-O, stability and timings.
  3. 193 Graphs, Recursion and Backtracking Build graphs in Java with adjacency lists, explore them with BFS and DFS, find shortest paths and run Dijkstra with PriorityQueue, then solve puzzles with backtracking.
  4. 194 Problem-Solving Patterns Learn three reusable Java patterns - two pointers, sliding window and prefix sums - and turn slow O(n squared) loops into O(n) solutions with runnable code.

Practice and Review

  1. 195 Java Cheat Sheet A one-page Java 25 cheat sheet with syntax, types, strings, control flow, OOP, records, exceptions, collections, lambdas, streams, dates, files and threads.
  2. 196 Java Programs: 40 Classic Examples 40 classic Java programs you can run - primes, palindromes, factorials, Fibonacci, GCD, Armstrong numbers, anagrams, matrices, patterns, sorting and more.
  3. 197 File and Directory Programs in Java Practice Java file handling with runnable programs - create, rename, copy and append files, compare paths, grep, measure and delete folders, search trees and read ZIP entries.
  4. 198 Class and Object Programs in Java Practice object-oriented Java with runnable programs - singleton, static members and init order, overriding vs overloading, data hiding, abstract classes and access modifiers.
  5. 199 Exception and Thread Programs in Java Practice Java exceptions and threads with runnable programs - multi-catch, Error vs Exception, unreachable code, thread states, sleeping safely, join, daemon threads and race conditions.
  6. 200 Java Practice Exercises 30 graded Java exercises with solutions on strings, loops, arrays, recursion, classes, records, exceptions, collections, streams and threads. Run them online.
  7. 201 Java Interview Questions 60 common Java interview questions with clear answers, from == vs equals and OOP to HashMap internals, streams, concurrency, garbage collection and Java 25.