Learn Java from Scratch with Practical Examples

Install a Java development kit—prefer Amazon Corretto—and an IDE like IntelliJ to compile, run, and debug Java apps, while using GitHub for version control.

JetBrains partners with this course to offer six months of IntelliJ ultimate access, with installation videos and a promo code at practicalcourses.net/IntelliJ, while you can continue using the free version.

Learn how to install IntelliJ IDEA on Windows, choose the community version, run the installer, set file associations, accept terms, and prepare to create your first Java program.

Install the java jdk for macOS using Amazon Corretto, download the latest version 15, and run the installer; verify with java -version showing open jdk 15.

Install IntelliJ for macOS from JetBrains, choose between Ultimate and Community, download, drag to applications, and navigate security prompts and privacy options before starting your first Java program.

install the Java JDK on Linux using Amazon Corretto, download the latest Java 15, install with dpkg, and verify the installation by running java -version.

Install and launch IntelliJ on Linux by downloading from JetBrains, selecting the community edition, copying the install command into a terminal, and completing privacy and data sharing preferences.

Learn to write basic Java code and explore variables, simple data types, comparisons with expressions, loops, control flows, methods, and how to store multiple values in a single unit.

Encourage students to rate the course and share feedback to help the instructor improve content and provide a better learning experience.

Set up the java development environment with the jdk and IntelliJ, and create a java project. Write a program using public static void main and System.out.println to print a line.

Explore how Java code is built from the class declaration to the main method, explaining keywords, access modifiers, and the print statement through System.out.println.

Access the course source code from the public GitHub repository, download and extract the zip, then open the Java project in IntelliJ to view the beginner code.

Explore variables in Java by declaring and defining them, and understand primitive and object reference types, including integers, longs, floats, doubles, booleans, chars, and strings, with naming conventions.

Explore Java primitive data types, including byte, short, int, long, float, double, boolean, and char, with practical examples on selecting suitable types for car data and basic type conversions.

Define and initialize primitive Java data types (byte, short, int, long, float, double, boolean, char) using car-related variables, apply literal suffixes (L, F) and exponent notation (E), and print results.

Explore how primitive data type conversions work in Java, covering widening (automatic) and narrowing (casting) with practical examples using variables as boxes.

Explore primitive data types in Java by performing widening and narrowing conversions, printing values, and handling data loss through explicit casting when converting integers to byte or double.

Practice with primitives by choosing a website, listing possible variables and their types, defining them in code, and printing them with System.out.println. The exercise prepares you for object references.

Explore object references in Java, contrast them with primitives, and learn to create objects using a class blueprint, the new keyword, and constructor parameters.

Explore object references and dot notation in Java, using print and getcolor on a Dodge Challenger, while noting built-in data types and String methods.

Explore object references in Java by declaring primitive and reference types, using new versus literals, and printing results with System.out.println.

Access the float value of an integer through Java object references to display a price with a decimal part. Practice string operations, using uppercase and lowercase and comparing with equals.

Explore core Java operators from assignment to logical operators, including arithmetic, equality and relational operators, unary, and ternary operators, with examples of division, remainder, and a coding lecture.

Learn Java operators, including comparison (==, !=, >, <, >=, <=), the ternary operator, logical (or, and), assignment shortcuts (+=, -=, *=, /=, %=), data type check, and bitwise operators.

Create a Java app to manipulate a Dodge Challenger price using arithmetic operators, compute increased and decreased prices, doubling, purchases from a fixed budget, and money remaining with modulo.

Explore unary operators in Java, including plus and minus signs, pre/post increment and decrement, and boolean negation, with practical examples using price and is damaged.

Demonstrate equality and relational operators with System.out.println outputs, test the car model data type using instance of, and use a ternary operator to indicate if the car is damaged.

Explore how Java logical operators evaluate conditions for a car, using not, or, and operators with price versus damage checks to decide if it's worth seeing or repairing.

Explore arithmetic and assignment operators in Java by manipulating a price variable with plus-equals, minus, multiply, divide, and remainder, and observe the printed outcomes.

Explore how loops in Java automate repeated tasks using while, do-while, and for loops, and control flow with continue and break, including nested loops and infinite loops.

Master while and do-while loops, nested loops, and continue and break using Bart Simpson's punishment example; build a Java class with a runnable main method and print loop counters.

Explore for loops in Java by writing a nested loop, managing variables like k and j, and using continue and break to control execution, observing scope and print results.

Explore control flow in Java by applying if, if else, and switch statements to make decisions based on conditions, with practical examples like car status, horsepower, and movie ratings.

Explore Java control flow with if-else and switch statements, modeling a car's state, color, and energy efficiency to print corresponding messages, including default handling for undefined categories.

Build a who wants to be a millionaire style Java app, define the correct answer, print the question and answer, and use if or switch to indicate correct or wrong.

Explore code blocks in Java, using curly braces to group statements, and learn about variable scope inside and outside blocks with for loops, if statements, and switches.

Practice code blocks in Java by declaring a variable in an inner block and observing that it cannot be accessed outside, illustrating inner scope and basic increment usage.

Learn how to define and call reusable methods in Java, including parameters, return values, and method overloading, with practical examples of input/output, static context, and access modifiers.

Master static methods and the main method in Java, including parameters, for loops, and printing with System.out.println. Learn about method overloading, return types, and a 10% discount example.

Explore Java methods by building an energy efficiency function using a switch for A–G with case-insensitive input and return value, plus a car description function with model, year, and condition.

Explore arrays in Java and learn to create, index, initialize, and loop through one- and multi-dimensional arrays, including default values and for loops.

Create and populate a java array and a multidimensional weekly lottery numbers matrix using for-each and nested loops, print values with System.out.println, and verify zeros default before assigning random numbers.

Master the basics by building your first Java application. Learn variables, primitives and object data types, operators, loops with Bart Simpson's Blackboard punishment as an example, control flows, and arrays.

Practice building a Java IMDb app using arrays and functions to store Tom Cruise data, compute age, print movies with rating-based labels via loops and if-else logic.

Learn Java foundations including packages, classes, objects, access modifiers, and the four object oriented principles. Explore final and static keywords, string functions, comments, clean code guidelines, and default variable values.

Discover how packages group related Java elements, distinguish built-in from user defined packages, define and name them, and use them via imports while avoiding wildcard imports.

Learn to organize Java code with packages, create and move between packages, use Java's random generator to produce 1–90, manage imports, and explore standard library elements.

Introduce object oriented programming with classes and objects, explain access modifiers and the four principles: inheritance, encapsulation, abstraction, and polymorphism through multiple examples for solid Java foundations.

Define a class and create objects with the new keyword, compare classes to objects, and use constructors to initialize state and handle empty objects.

Build a basketball player class with a constructor, a free throw method using random numbers, and loop over an array of players to invoke it.

Practice building classes and objects in Java by defining fields, a constructor, and at least one method, then use the class in a main method for hands-on feedback.

Learn how access modifiers control visibility in Java, including default (package-private), private, protected, and public, with examples of exposing the engine while hiding internal pumps and variables.

Explore how access modifiers shape usage of constructors and fields in Java, making fields private and constructors public, with hands-on examples using a Dodge Challenger class and encapsulation concepts.

Explore inheritance in Java by defining a subclass from a superclass using extends, understanding is-a relationships, method overriding, and five inheritance types: single, multi-level, hierarchical, multiple, and hybrid.

Learn how to use inheritance to organize code by creating car and athlete packages, extending a car class, and overriding methods with super to call constructors.

Practice inheritance by creating a superclass from existing classes, moving common fields up, and overriding a new method in subclasses like cars and basketball players.

Explore encapsulation in Java by using public get and set methods for private variables, guarding price and mileage with constructors and Math.abs, and applying car subclass behavior.

Practice encapsulation by extending athlete class with a play game method, get/set for team, and functions for free throw percentage, points per game, and passing yards for basketball and football.

Practice encapsulation in java by adding set and get methods for a private variable, plus read-only and write-only accessors, then use them in the main class and print.

Explore abstraction in Java through abstract classes, abstract methods, and interfaces, with real examples like cars and athletes; compare encapsulation and abstraction and learn their advantages.

Convert the car class to an abstract class with an abstract start the engine method, then create an electric engine interface and implement it in the Dodge Challenger.

Learn how to apply abstraction in an athlete example by creating an abstract athlete class, implementing get body type across subclasses, and introducing a swimming interface for swimmers.

Practice abstraction in Java by making a class abstract, adding an abstract method, creating and implementing an interface, and using these in the main class to print output before polymorphism.

Explore polymorphism in java, including method overriding and overloading, and how polymorphic variables let a single interface operate on multiple subclasses, reducing code duplication.

Explore method overriding and overloading in Java using the car example to demonstrate polymorphic variables, constructor overloading, and how different return types affect method resolution.

Learn how method overloading works in Java by adding a distance parameter to a freestyle method, implement interface methods, and observe overloaded calls in the athlete app.

Practice polymorphism by applying method overloading to an existing function or constructor, then use the overloaded versions in the main class, building on previous overriding lessons.

Learn how to apply the final keyword in Java to prevent changes, overrides, and extensions, including final variables, final methods, and final classes. See a country example where name is final, initialized in a constructor, a final method for population changes, and a final class that can't be extended.

Master the static keyword in Java, learning how static variables, methods, and blocks enable class-level access and data sharing without creating objects.

Explore the static keyword in Java by modeling a country class with a shared static counter for created objects, and using static and non-static methods to print details.

Explore Java string functions with hands-on examples using keyboard input, including equals, equalsIgnoreCase, contains, length, toUpperCase, toLowerCase, startsWith, endsWith, and replace, plus null handling and safety.

Learn how Java comments explain code and aid testing, with single-line and multi-line styles. Explore best practices, including meaningful names that reduce the need for comments.

Learn how to use single-line and multi-line comments in java, with hands-on practice from the string function app, and master meaningful variable names and IntelliJ commenting shortcuts.

Explore clean code and three core principles—dry, kiss, and yagni—that reduce duplication, keep code simple and readable, and guide when to implement or avoid features.

Explore how Java assigns default values to numbers, booleans, chars, strings, and objects, and learn how null and zero defaults influence constructors and potential null pointer issues.

Explore default values for Java data types through a simplified car class, showing zero numbers, false booleans, and no defaults for object types, plus why local variables require initialization.

Master intermediate java concepts by creating packages, classes and objects, and using access modifiers. Apply inheritance, encapsulation, abstraction, and polymorphism, plus static and final keywords and common string functions.

Build the Great Robbery App from scratch in the intermediate final practice, using packages, classes, constructors, access modifiers, four object oriented principles, static and final keywords, loops, and functions.

Build a Java class hierarchy for a crime story, with an abstract person base class, and concrete criminal and detective subclasses, plus item, building, and city models.

Design and simulate a Java city crime scenario by building gang, police, and city classes, implementing robbery logic, random outcomes, and a main loop that runs until criminals are caught.

Explore enums, classes, time types, and the object class, with hands-on coverage of collections and generics. Understand exceptions, file handling, and core utilities like math and string functions.

Explore enum as a special type of class to store limited pizza sizes like small, medium, large, and extra large; define constructors and use built-in values, valueOf, ordinal, and name.

Demonstrate using Java enums with a pizza size enum, calculate price by size via a switch, and display order details plus all available sizes.

Explore inner classes in Java, including static and non-static inner classes, anonymous classes, and method-local inner classes, and learn when and how to use them to improve encapsulation and readability.

Explore how to create and use inner class types in Java—anonymous, local, and static nested—through a pizza example featuring a pizza slice inner class that calculates area.

Learn to use static nested classes and the builder pattern to construct a pizza with mandatory and optional parameters, enabling fluent, chainable method calls.

Understand the roles of the jdk, grey, and the jvm in compiling, running, and executing Java programs.

Explore how Java compiles to bytecode by inspecting the out and src folders in IntelliJ. Compare .class files with .java sources and view decompiled code for inner classes.

Explore built-in Java array functions like equals, fill, sort, toString, copyOf, copyOfRange, and search. Apply these helpers to primitives and strings, noting that object arrays require more development.

Explore Java array functions in action, including fill, sort, copyOf, copyOfRange, equals, and binarySearch, through a hands-on gamer points example.

Explore Java math functions to compare, round, and randomly generate numbers. Learn absolute value, min, max, round, ceiling, floor, random, power, and square root with practical examples.

Explore how Java's math functions compute absolute values, min, max, round, ceil, floor, pow, and sqrt using a random temperature scenario.

Master debugging with a debugger to run code in a controlled environment, inspect inner state, evaluate expressions, set breakpoints, and step through logic to identify and fix bugs.

Learn java time types, including local date, local time, local date time, calendars, time zones, and formatters, with practical conversion and modification examples.

Learn to use Java time types like local time, local date, and local date time to manage restaurant opening hours, orders, delivery times, and time comparisons.

Explore java time types with hijra calendar, date time formatter patterns, and zone date time conversions. Use examples like a pizza order across time zones and listing available zone IDs.

Explore how to display and collect data using System.out, System.in, System.err, and the Scanner class, including print, println, printf, and format specifiers for numbers and strings.

Create a console game character creator that collects name, race (human or orc), difficulty (0–2), and nightmare mode, using a scanner and printing a summary with printf.

Explore the differences between String, StringBuilder, and StringBuffer, noting String immutability, memory implications, and when to use each for efficient concatenation and thread safety.

Compare runtime performance of String, StringBuilder, and StringBuffer while building numbers 0 to 100,000; show milliseconds and advise: strings for non-loop use, StringBuilder for non-thread-safe cases, StringBuffer for thread-safe needs.

Explore the built-in Java Object class, the universal superclass whose inherited methods—clone, equals, finalize, getClass, hashCode, and toString—underpin every object, with notes on garbage collection and basic multithreading utilities.

Learn to implement cloning in Java by overriding clone on the pizza class, implementing Cloneable, handling clone not supported exceptions, and casting the result back to Pizza.

Learn how to properly override equals in Java to compare two pizza order objects by name, price, and size, using auto-generated templates and a manual approach with consistent hashCode.

Explore why finalize is deprecated and how the garbage collector interacts with object finalization, highlighting safer alternatives, compatibility concerns, and the risks of finalizers.

Learn what hash codes are, why they matter for equals, and how to implement them to avoid collisions in hash-based collections like HashMap and HashSet.

Override hashCode to create robust hashing for objects, explore how Objects.hash computes hash codes from name, size, and price fields, and ensure consistency with equals.

Override toString to provide information for debugging and logging, showing selected fields like name, size, and price; IntelliJ can generate it, while default prints class name and hash code.

Discover Java collections framework, its list, set, queue, and map types, and how dynamic sizing and key-value storage power practical data handling from shopping carts to dictionaries.

Learn Java's ArrayList for a web shop's products, including add, remove, set, get, and size. Build a product class with name, price, description, generate constructors, getters, setters, equals, hashCode, toString.

Explore ArrayList coding techniques with add all, sort, reverse order, swap, and shuffle, using a to-do list example to demonstrate contains, isEmpty, clear, subList, and other collection utilities.

Explore the vector class in Java, compare it with array list, and learn its thread-safety, extra functions, capacity versus size, and usage in multithreaded contexts.

Explore linked lists in Java: how nodes and pointers form a dynamic, memory-efficient list, compare to array lists, and learn when insertions and deletions beat searches.

Explore generics in Java with examples like ArrayList and a typed box that stores any data type. Learn about raw types, type parameters, type inference, and key restrictions on generics.

Discover generics in Java by defining a two-parameter pair interface and an ordered pair class, then apply them in practice with array lists of countries.

Explore the essentials of Java generics, including bounded type parameters, multiple bounds, bounded methods, wild cards, and type erasure, with practical examples.

Explore generics with wildcards, lower bounds, and unbound types, and see how array lists, add numbers, and print list demonstrate static functions and diamond operator rules.

Learn generics and wildcards in Java, using the diamond operator and question mark, compare simple generics with wildcards, and manage static versus instance typing with ArrayList and List.

Explore how exceptions disrupt program flow and learn to use try-catch and finally blocks, understand exception objects and handlers, and distinguish error, runtime, and checked exceptions.

Learn to handle unchecked exceptions in Java by using try-catch-finally around division, catch arithmetic exceptions from zero division, and use printStackTrace for debugging while keeping final blocks running.

Understand the difference between unchecked and checked exceptions in Java, and learn to use throws and try-catch blocks, plus finally, to manage file writing with print writer and file writer.

Explore practical exception handling in Java, including recovery strategies such as safe file creation and a zero division fallback, and master try-with-resources to auto-close resources and simplify code.

Learn how the throws keyword transfers exception handling and how to catch multiple exceptions with the same code, including number format and zero divisor exceptions.

Avoid swallowing exceptions by leaving catch blocks empty and not printing errors; rethrow with the original exception data, and use finally only to close resources, not for switching between catches.

Examine the most commonly thrown Java exceptions and errors, including IO exceptions, array index out of bounds, class cast, illegal argument, illegal state, number format, null pointer exceptions.

Demonstrate tokenizing a string with string tokenizer and the split function, showing how to set delimiters, count tokens, and limit results using a Star Wars example.

Learn how to create files in Java using the file class and the create new file method. Understand try catch handling, the boolean return, and how paths must exist.

Explore the Java file class to diagnose files and directories with functions like getName, exists, isFile, isDirectory, and path handling. Inspect last modified times, storage metrics, and permission controls.

Learn to read from a Hamlet text file in Java using FileReader, with try-with-resources, and read the first 100 characters into a char array.

Explore how the buffer reader improves on file writer by reading by lines and working with other reader objects, and how to set the buffer size.

Read a file in Java with the scanner, path, and try catch. Read line by line or word by word, use hasNext, set delimiters, and type-specific next methods.

Compare the buffer reader and scanner for file input, highlighting thread safety, adjustable versus fixed buffer sizes, and the ability to parse primitives versus reading raw data.

Learn file handling with the FileWriter class: create files from a string path or file object, write text, and use append or overwrite with new lines.

Learn how the buffered writer collects data in a buffer and writes when full. Use a file writer as the underlying writer, set buffer size, and flush.

Learn to use print writer for file handling, create a print writer from a file writer or stream, print and println, and enable append mode with the file writer constructor.

Explore how the Java Path class handles file paths, including retrieving file names, subpaths, parent and root elements, and converting relative paths to absolute paths.

Learn to copy and move files using the Path and Files classes, handle existing files with replace existing, validate paths with exists, and move files between folders.

Learn to read hangman words from a text file using a scanner, implement a game service with a start method, and fetch a random word from the loaded list.

Define a private get random word function that returns a random word from the words list using a random number generator, and print it; handle file not found with throws.

Handle incorrect guesses in hangman by using an else block to decrease chances, inform the user, and reveal the word when chances run out before breaking the loop.

Learn how to finish a Hangman game in Java by handling a correct guess, revealing letters, checking for completion with underscores, and printing winning or losing messages for the user.

Explore maps in the collections framework, learning how key value pairs work, when to use hash map, linked hash map, hash table, and tree map for ordered data.

Learn how to create a hash map with the map interface, store country names as keys and capitals as values, and perform put, get, and remove operations, including key overrides.

Master Java hash maps by using containsKey and containsValue to check keys and values, use get for retrieval, and apply getOrDefault and replace for defaults and updates.

Learn to loop through a hash map, print keys and values, and handle nulls with put if absent, containsKey, size, and clear.

Compare hash map, linked hash map, and tree map using a product example; linked hash map preserves insertion order, while hash map does not, with notes on memory and synchronization.

Explore how TreeMap stores elements and differs from HashMap and LinkedHashMap, showing alphabetic order and the prohibition of null keys. Preview extra TreeMap functions in upcoming lectures.

Explore TreeMap in Java, its navigable map features and extra functions, including first key and last key, with coding examples.

Explore TreeMap features by printing keys and using the descendant key set and descendant map, plus lower key, floor key, higher key, and ceiling key to fetch closest keys.

Explore TreeMap entry functions, including first and last entries and their poll variants, and lower, floor, higher, and ceiling entry that return the full entry with key and value.

Explore java treemap extra functions head map, tail map, and sub map with practical examples showing elements around a key and inclusive behavior between keys.

this lecture explains why hash table is deprecated in the java collections framework, and recommends hash map for non-thread-safe use or concurrent hash map for thread safety.

Learn how hash sets in java store unique elements, like car models, without guaranteed order, and master essential operations such as add, contains, size, remove, and clear with practical examples.

Explore hash set operations in Java: add all, contains all, retain all, and remove all, using car brands examples to manage original and least reliable sets.

Discover how linked hash set preserves insertion order, unlike hash set, and how capacity and load factor (default 16, 0.6) control resizing.

Explore the most useful TreeSet functions, including lower, floor, ceiling, higher, headSet, tailSet, subSet, first, last, pollFirst, pollLast, and descendingSet, with comparisons to Treemap and HashSet behavior.

Explore how queues remove from the head and add to the tail. Compare with the deque that supports both ends and three main classes: linked list, priority queue, and deque.

Explore how a linked list implements the list interface and can act as a queue or dq, using add, offer, peak, element, remove, and pull.

Discover using a linked list as a deque in Java by applying queue functions from both ends, with add last, add first, remove first, remove last, and peak first/last.

Explore the stack data structure, its push and pop operations, and how edit history in text editors uses lifo to undo changes. Understand why stacks differ from fifo queues.

Learn to implement a Java stack using Deque with a LinkedList, using push, pop, and peek to manage an edit history of strings.

Compare Linkedlist as a dequeue and array dequeue, noting array uses less storage, Linkedlist stores neighbors via links, and array deque cannot store nulls; choose accordingly.

Learn how the priority queue keeps the smallest element at the head, while the rest remain unorganized, and why null elements cause a null pointer exception, with queue-like operations.

This lecture introduces functional programming and contrasts it with object oriented programming, showing how functions can act like variables and be passed as actions, with upcoming lectures clarifying the details.

Explore passing actions in object oriented programming without functional programming via a welcome message service. Implement a greeter interface with classes for logged in and guest users to vary output.

Explore functional programming in Java by converting normal functions into lambda expressions, creating function type variables, and enabling functions as values via the arrow operator.

Learn how to convert functions to Java lambda expressions, pass lambdas as parameters, and implement one- and two-parameter forms, including short forms and division-by-zero handling.

Learn how Java uses interfaces as functional types, requiring a single abstract method with a matching signature, and implement lambdas with correct parameters and return types.

Learn functional programming in Java with a function type and greeter interface, using lambda expressions. Pass lambdas to the greet function and run them without extra classes.

Organizes a simple java program that uses a scanner to read user status, applies lambda expressions for greetings, and handles null-safe comparisons with if-else and a fallback for unknown status.

Learn to build a number operation service using a functional type and a functional interface, applying a lambda to a list of integers, with type inference and printable results.

Explore Java streams as a fast, pipeline-based approach to processing lists, and learn to map and filter with lambdas while collecting results into a list for practical demonstrations.

Explore built-in functional interfaces in Java, including consumer, bi-consumer, bi-function, predicate, unary operator, and supplier, and learn how they support lambda expressions and custom interfaces.

Learn the Java consumer interface, using one-parameter lambdas that return nothing; use accept with Integer and lists to multiply numbers and modify list elements.

Learn how to use BiConsumer and distinguish it from Consumer, with two-parameter lambdas, type parameters in the diamond operator, and how to parameterize actions on a list.

Learn how the BiFunction interface contrasts with Function and BiConsumer, implement a two-parameter lambda that returns a result, and apply it to power calculation and list generation.

Explore the predicate interface in Java, its test and negate methods, and how to combine predicates with and and or for use in streams.

Learn to use predicate as a function parameter and apply predicates in streams with lambda expressions, filtering numbers to produce odd or even results.

Explore the unary operator interface that returns the same type and enables generics with lambda expressions, then implement a generic function to apply the operator to each list element.

Learn to implement a supplier-based lambda with a diamond operator and empty parentheses that returns a random integer from 1 to 1000, using a Random object and printing results.

Learn how streams in Java simplify collection operations like filtering and collecting with shorter, readable code. See an animal list example using filter and collect to produce a result list.

Explore streams in Java by turning a list of temperatures in Celsius into a stream, filter values, collect to a list, sort, count, and chain multiple filters.

Explore creating and processing streams in Java, including dot stream, dot sorted, for each, and collect to list; learn res.stream with arrays and range-based int, double, and long streams.

Learn to replace simple lambdas with method references in Java, especially with streams, and explore static, object, instance, and constructor references and when to use them.

Learn to use instance method references of a certain type with a person class, sort by age using a comparator, and replace lambda with a method reference.

Explore instance method references of an object by defining a compare-by-name-and-age function in a provider class, then use an object's method reference to sort by name and age.

Master static method references in Java by using the class name and double colon, and learn when to make methods static for reuse across classes.

Learn to use constructor method references to transform collections with a generic transform method, turning a list into a set or a tree set, and ensuring duplicates are removed.

Learn how to use streams filter with predicates to select cereals by rating and price in Java. Practice combining conditions with and/or and printing results with forEach.

Discover using forEach with streams to filter items into a new list, replace lambdas with method references, and iterate a map to print product name, brand, and price.

Master the streams sorted function, including reverse order and object sorting with comparator and method references. Sort by price, then by name in reverse, and collect results.

Learn how the distinct function removes duplicates from a stream as an intermediate operation. Define equals and hashCode for custom objects to enable duplicate detection, shown with fruits and cereals.

Discover how the stream map function, an intermediate operation, transforms elements into new data, with three examples: capitalizing words, mapping objects to names, and creating objects with higher prices.

Learn how to use collect with toList, toSet, toMap, and toCollection to shape streams, remove duplicates with distinct, and map fruits to uppercase while handling duplicate keys.

Learn how collect() joins stream elements into a string with a separator, counts elements, and builds simple statistics, demonstrated with RPG game player names and parallel int and double lists.

Explore java streams for summing and averaging using collect and collectors, converting int and double sources, and summarizing to obtain count, sum, min, max, and average.

Partitioning by splits fruit boxes into cheaper and more expensive groups by price, while grouping by name collects boxes into lists; the example counts elements and sorts results by key.

Use stream collect with maxBy, minBy, and teeing to find the hottest and coldest months from weather by month data, including daytime and nighttime temperatures.

Learn how to use flatMap to combine elements from nested collections into a single stream, compare it with map, and collect results with distinct, list, and set examples.

Learn to use map and reduce on streams to compute a shopping cart total with a discount, including an initial value, then print subtotal, discount, and final total.

Discover how to use limit and skip on streams to select top three least and most expensive items by price, sorting with a comparator, and collecting results for display.

Learn how to use Java streams allMatch, anyMatch, and noneMatch to evaluate conditions across elements, with practical examples of fruit box prices and availability.

Explore Java streams by using int stream range and range closed to generate number sequences, filter those divisible by 10, and map to a double stream yielding 0.1 to 0.9.

Discover how the peak function in streams can be used for debugging with println and for modifying elements, such as adjusting prices, while chaining filter and collect operations.

Explore streams with find first and find any, compare their behavior, and learn how optional wrappers and get access to the retrieved element from a fruit boxes example.

Explore count versus size for counting elements, and compute min and max by price using a comparator, then extract the inner object from the optional with get.

Explore using streams to analyze a list of planets, identify habitable candidates by temperature and distance, and practice distinct, min, max, and sorting techniques.

Fetch planets from the repository, remove duplicates with distinct, and count them. Use streams to find the biggest, coldest, and hottest planets with optional handling and print their details.

Learn how to find the top ten most habitable planets by filtering solid planet types and sorting by temperature difference from Earth and distance from Earth using Java streams.

Find the planet whose closest star distance matches earth-sun distance using Java streams and a comparator with absolute differences. Learn to use min and print results with System.out.println.