SDET: Java Lambda & Streams Masterclass [Selenium WebDriver]

Explain the difference between the Java development kit and the Java runtime environment, noting that the JDK includes the JRE and tools like javac and debuggers.

download and install the JDK starting with Java 8, and use the latest JDK version when available, following OS-specific installers (dmg, exe, tar) and setting path variables.

Choose and download your IDE for Java development; I recommend IntelliJ, but you can use Eclipse, NetBeans, or Visual Studio Code, and install the free Linux community edition from JetBrains.

Create a new Maven project in IntelliJ, select Maven, configure the JDK path, set groupId and artifactId (comm.udemy.java and udemy-java), then finish and enable auto import.

Update IntelliJ settings to ensure JDK 1.8 or above, set language level and SDK, and add a new JDK if needed to align modules with lambdas and type annotations.

Check the project structure and settings to align the Java compiler with the chosen Java version, ensuring Java C is selected and versions match to prevent weird debugging issues.

Master primitive types in Java, including byte, short, int, long, float, double, char, and boolean, as basic value types with no references or methods, and guide memory and range decisions.

Explore how primitive types in Java are passed by value through a hands-on demo: a method increments a primitive, but the original value stays unchanged.

Discover how reference types in Java store object references, not values, and mutate an integer array in place through methods, demonstrated by before and after changes.

See how Java treats arrays as objects, how changing elements via a reference updates the original, and how passing the reference by value differs when a new array is created.

Explore how Java passes a copy of the reference by value and how mutating an object inside a method can cause unexpected results, highlighting immutability in Java 8 style.

Avoid mutation by copying the input array with Arrays.copyOf to create a new array and keep the original intact, noting that mutating methods exist but should operate on the copy.

Explore polymorphism by examining compile time polymorphism through method overloading and multiple parameter types. Observe runtime polymorphism through method overriding and how area calculations adapt for square and rectangle.

Master runtime polymorphism and inheritance in Java by exploring reference types, null pointer behavior, and an animal hierarchy with a common interface for shared features.

Learn runtime polymorphism and inheritance by building an animal hierarchy (dog, cat, horse) with overriding make sound and walk methods.

Demonstrate runtime polymorphism and inheritance by assigning an animal to dog, cat, and horse to call makesound and walk; note toy must extend animal to compile and preview interface-based polymorphism.

Explain the difference between abstract classes and interfaces, and illustrate when to use each with an animal hierarchy and alarm feature examples.

Demonstrates interface-based polymorphism by implementing an alarm interface in iPhone, Google Mini, and clock. A single set alarm method accepts any implementing object, enabling runtime polymorphism.

Explain how interfaces define contracts and cannot be instantiated, requiring class implementations; outline Java seven limitations, and how Java eight and nine introduce changes for lambda and streams.

Explore the collections framework to store similar objects in memory, using interfaces like list, set, queue, and stack, with operations such as search, sort, insert, and delete.

Find the maximum among numbers and learn why lists and array lists in the collection framework let you manage many objects, like animals or alarms, as a single collection.

Explore how wrapper classes enable collecting primitive values in lists by boxing and unboxing, and distinguish between primitive and reference types in Java collections.

Review primitive and reference types, wrapper classes, boxing and unboxing, and mutation; compare compile-time and runtime polymorphism via interfaces and abstract classes, and collections over arrays.

Learn how to create lambda expressions in Java by implementing a single-method interface inline, using the arrow syntax to reduce verbosity and test greeting implementations.

Learn about SAM: single abstract method interface, and how the functional interface annotation signals lambda usage, enforcing a single method while remaining optional for lambdas.

Explore how to write single-line and multi-line lambdas in Java, using braces and semicolons, and learn to pass parameters, invoke lambdas, and access values like name length.

IntelliJ suggests replacing a single abstract method interface with a lambda, automatically converting a greeting service instantiation into a lambda expression.

Explore how a lambda, essentially a function, returns a value with a single parameter and converts it to uppercase.

Define functional programming as building software with pure functions and no shared state or side effects. Show how pure functions yield consistent, predictable outputs using lambda concepts.

Learn how functions act as first class objects by creating a function, assigning it to a variable, and treating it as a reference type rather than a primitive value.

Explore higher order functions in Java by creating and passing lambda functions as parameters, enabling customizable behavior and function-as-a-value workflows introduced with Java eight.

Explore higher order functions by contrasting passing data with passing behavior. Learn to design methods that accept behavior, enabling flexible, data-driven transformations in a functional programming style.

Explore how a lambda provides behavior to a test method and executes only when invoked, not at declaration, and follow the order including get number and receive number.

Explore higher order functions in Java by returning lambdas from methods and treating functions as first-class objects within a greeting service example.

Explore method references as a compact alternative to lambda expressions, using single-line lambdas and the double colon syntax to forward data to existing methods.

Dive into java method references in this second part, using static and instance methods for string operations, such as objects.isnull, touppercase, and chaining single-line lambdas with the double colon syntax.

Explore method references for two-parameter string operations by using the instance method concat on the first argument and passing the second, illustrating how S1 concatenates S2.

Master method references in java with the double colon syntax, replacing lambdas in static and instance method calls, list.add, System.out.println, and string operations like toUpperCase, concat, and replaceAll.

Begin the calculator assignment by implementing a math operation functional interface with operate(int, int) returning int, then define and test add, subtract, multiply, and divide lambdas.

Implement a calculator using a functional interface math operation with the operate method, then define add, subtract, multiply, and divide as lambda expressions and test them in a main class.

Refactor the calculate method to accept three parameters (onscreen number, operation, entered number) and simulate pressing equals using hardcoded test data to yield the correct result.

refactor a calculator engine to accept three parameters and chain operations, demonstrating on-the-fly behavior with lambdas and how parameterization replaces multiple methods.

Explore how lambdas enable anonymous functions, first-class objects, and higher-order functions through functional interfaces and method references, with guidance on pure functions, immutability, and concise lambdas.

Explore Java eight functional interfaces and the value of standard ones. See how List and Map accept interfaces such as Consumer, aligning with strictly typed code.

Explore the supplier interface in Java eight, featuring a no-parameter get method, generics, and diamond operator, then generate a random number with a lambda or method reference for test automation.

Learn to use a driver factory and Java suppliers to instantiate WebDriver instances for Chrome and Firefox, streamlining browser initialization in a Selenium test framework.

Demonstrate validating driver suppliers in a Selenium test by running a Chrome driver and switching to Firefox, using a hardcoded value to simulate the driver factory test.

Explore the consumer interface in Java, which accepts any type using the generics diamond operator and performs actions without returning values, via the accept method or method reference.

Demonstrate using a list to feed a consumer, printing and transforming strings with lambdas. Show how to print link text from web elements via forEach, handling cases with no text.

Learn how to use lambda chaining to compose multiple consumers, enabling both database writes and log file updates with a single combined consumer.

Create a map of string to consumer of string, put db and log consumers in the map, and retrieve a consumer via a system property to chain behaviors without if-else.

Explore the BiConsumer interface in Java, which accepts two inputs via generics, shows map iteration with two parameters, and supports chaining BiConsumers for key-value processing.

Master consumer chaining in Java lambda expressions by ensuring all chained consumers share the same type. Mixing string and integer consumers breaks chaining in functional composition.

Explore why Java lacks a tri consumer, explain how to create custom functional interfaces, and show how to use collections or a single object like person to avoid excessive parameters.

Master predicate interfaces in Java: accept a generic type with the diamond operator, use test method with the t parameter, and chain with and, or, and negate for two-element decisions.

Demonstrate using predicates to enforce rules, such as checking numbers greater than two and less than ten, chaining predicates, and negating conditions to control truth values.

Demonstrate using a predicate to remove blank links in test automation by filtering web elements with trimmed text length, showing before and after results.

Apply a predicate-based, functional style to print links that do not contain the letter s, case-insensitive, as an assignment following the lesson on removing blank lines.

Remove links containing s by converting text to lowercase and checking for s, using blank-first removal or one-by-one processing to leave three links.

Explore creating predicate rules with a rules engine in Java, using static methods and a list of predicates to filter elements, apply remove-if logic, and refactor with a method reference.

Explore function concepts for transforming inputs to outputs, using apply and compose, and study generics with the diamond operator <t, r> (input t, return r).

Shows how to create and chain functions, such as computing string length and squaring the result, while enforcing input/output type compatibility for reliable function composition.

Explore the difference between andThen and compose in java functions with lambda examples that add two and square, highlighting return type compatibility and potential compilation errors.

Compare consumer and function chaining in Java: consumers pass the same input reference through andThen, while functions pass each step's output as the next input, enabling transformations.

Explore core functional interfaces like runnable, callable, and supplier, highlighting their single abstract methods, compatibility with lambda expressions, and how Java eight adds the functional interface annotation.

Demonstrate runnable as a no-argument, no-return interface, use a lambda to run code in a separate thread, printing hello world and hi to illustrate concurrency.

Explore Java's callable and supplier; callable may throw checked exceptions and requires try-catch or throws, unlike supplier, reflecting Java's strict typing. Matching types callable or supplier are accepted by methods.

Develop a calculator class that parses space-separated expressions and supports basic math operations via a map. It can add new operations, like power or mod, without modifying the class.

Split the input string by spaces to form an array, take the first number as the on screen number, and process subsequent pairs to apply operations like plus two.

Implement a calculator in Java using a static map of string math operations, parse a space-delimited expression, and apply plus, minus, multiply, and divide to update the on screen number.

Explore using lambda-based operation maps to extend a calculator on the fly, adding power and mod features without changing the core class.

Explore the introduction to Java streams, explain how streams differ from data structures, and how lambdas enable stream usage, with a preview of what streams are and how they help.

Compare traditional for and while loops, which pull data and risk array index out of bounds, with streams that push data to you and enable transform, filter, and composition.

Create a list of integers in Java, check for even numbers, compute their squares, and print each on a new line using a loop; next, compare with streams.

Learn to use java streams to filter even numbers, limit to three results, transform each to its square, and print the squares to the console.

Understand how a Java stream processes data through a stream pipeline. Apply filters to allow only even numbers, square them, and enforce a limit to stop further processing.

Observe how data flows through a stream pipeline, showing per-element processing with filter, limit, and map, and using debug prints to reveal what passes and how values transform.

Explore stream operation types—intermediate and terminal—and learn how multiple intermediate operations can be chained in any order, while a single terminal operation consumes the stream lazily when connected.

Demonstrate stream laziness by showing that intermediate operations remain unexecuted until a terminal operation connects the stream, as debugging statements reveal no map or filter results without a terminal operator.

Explore core intermediate stream operations like filter, map, limit, skip, peek, distinct, and sorted, driven by predicates and functions to transform data through the pipeline.

Understand the map operation in Java streams, the sole intermediate transformer that changes data types, converting values like integers to strings within the pipeline.

Understand how sorting in streams collects all data before sorting, so filters and maps act on the sorted sequence, and limit placement can affect the output.

Learn to use peek in a stream pipeline as an intermediate operation for debugging. Apply it to map, filter, and limit, and show how to comment it out.

The lecture demonstrates how skip and limit operate in streams, showing which items are ignored or taken and how pipeline order shapes results.

Master advanced java streams by chaining filter and map operations to select even numbers greater than five, square them, add two, and print results to the console.

Practice building streams from web elements to filter non-blank links, exclude those containing s, transform link text to uppercase, and print to the console using Java lambdas in Selenium tests.

Learn to process Google link texts with Selenium streams: filter non-blank links, perform case-insensitive exclusion of strings containing s, and map texts to uppercase for output.

Demonstrates running the test to produce a three lengths output after addressing audio issues and redoing the demo. Clarifies the live demo flow for this and the following lecture.

Improve the Google links assignment by converting a stream of web elements to a stream of strings, trimming text, and using method references to map and print.

Demonstrates executing a test by right-clicking to run and reviewing the resulting output, illustrating practical test execution workflow.

Explore how Java streams behave on an empty list. Verify that the stream performs no operations and prints nothing when the list is empty, avoiding exceptions.

Explore how functional style with Java streams simplifies data filtering and testing in Java, showing predicates, test data, and easy predicate-driven customizations versus traditional loops.

Practice a functional style with streams by completing an assignment that builds a test method to access the page and retrieve all checkboxes. Select them using the consumer predicate function.

Create a checkbox selection test in selenium webdriver by locating input elements with the driver using tag name, clicking the corresponding web element, and running the test.

Select checkboxes by gender using Selenium WebDriver, guided by test data to choose all male or all female options in the assignment.

Learn to locate table rows with tr and cells with td, identify the gender from the td, and click the corresponding checkbox using Selenium WebDriver in Java.

Learn to select a checkbox by gender in a web table using Java lambda and streams with Selenium WebDriver, navigating TR and TD cells, and clicking the checkbox.

Apply data provider testing to feed gender values (male and female) via an object array, and parameterize the test to select the corresponding checkbox.

Add a filter to the stream to ensure the TD list has four elements before access, preventing index out of bounds when an empty tr appears.

Convert the test into a page object by creating a pages package and a table demo page class that handles navigation and selects rows by gender with a WebDriver.

Make the table's select rows method generic to support multiple criteria, such as gender, country, or name, with minimal code changes and improved maintainability and testing.

Make the select rows method generic by accepting a predicate, enabling a lambda-based higher-order function to decide which rows to select from a list of web elements.

Pass a predicate of a list of web elements as a data provider. Test all male or all female predicates on the second cell text ignoring case.

Use lambda predicates to filter test data by gender. Replace strings with predicates and control records via a data provider; enable all gender, all male, or all female cases.

Apply country as a predicate using Java lambdas to filter rows by gender and country (EU, Australia), expanding test coverage with data-driven, functional style Selenium tests.

Explore passing predicates in BDD and cucumber with a search criteria factory and driver factory, using a static block and maps to return a predicate for lists of web elements.

Demonstrate passing predicates as parameters to filter records by gender in a BDD scenario, validating male, female, and all records with lambda-based conditions.

Explore flatMap to flatten a stream of lists, turning a list of lists (table-like rows and columns) into a single stream of elements for element-by-element processing.

Demonstrates using flatMap to flatten a list of lists into a single stream, printing numbers 1–9 and then showing how to generate squares with subsequent mappings.

Explore stream terminal operations and how to terminate a stream to obtain results, using for each, collect, count, minimum, maximum, find first, find any, any match, none match.

Explore the terminal operation count in Java streams, compare stream count with list.size, and learn to filter strings longer than three characters to obtain counts.

Use streams to filter words longer than three characters and find the first match with findFirst. Explore how Optional wraps the result and how to check presence before using get.

Learn how min and max operate on streams using a comparator, with natural order for ascending and reverse order for descending. Handle optional results with get and filter by length.

Explore anyMatch and noneMatch in java streams, determining if any element satisfies a condition and if none do, with examples like checking for the letter e and avoiding z.

Explore terminal operations for test automation, then set expectations for future lectures that cover test automation examples across multiple sessions.

Create a link util class to find broken links by connecting to a given URL and returning its HTTP response code (200 or 404), ready to reuse in any framework.

Learn how to use the LinkUtil's getResponseCode to validate URLs by testing 200 and other codes such as 404, 500, and 0 to distinguish site reachability and server issues.

Use the provided URL from your resource section to find the broken image links on this page hosted on a Heroku app.

Create a TestNG test to identify broken links by extracting all elements with a source attribute using XPath, collecting their URLs, and preparing to validate them in the next lecture.

Identify broken images by extracting src attributes, fetching their response codes, and printing the URL and status to reveal 404s and other failures.

Discover how to find broken links using the href attribute with Selenium WebDriver, and verify image and script resources by comparing href and src attributes on a demo practice site.

Use anyMatch with a predicate to verify source attribute URLs return 200, flagging broken links and images via response codes like 404 in a Selenium WebDriver test.

Apply the collect method to gather broken links by checking each source with LinkUtil's get response code and filtering non-200 results, then assert the list size is zero.

Explore terminal operations in java streams by using collect and to list, learn the most frequently used patterns, and preview upcoming topics for the next lectures.

Learn to collect filtered stream elements into a new list using toList, selecting words longer than three characters, while the original list remains unchanged.

Collect data into a set to remove duplicates, compare set versus list performance, and use Collectors.toSet for words longer than three characters, noting that sets do not preserve order.

Join words from a stream into a single string using collectors joining, with optional delimiters, and compare with pre-Java 8 approaches for cleaner code.

Use java streams and collectors.groupingBy to group data into maps by a chosen key, such as word length or first character. In test automation, group urls by http response code.

Explore findAny in Java streams, compare it to findFirst, and understand why both terminal operations exist, with a preview of an important stream feature to be covered next.

Demonstrates how parallel streams speed up link checks by processing hrefs in parallel, showing time savings from 13 seconds to 3 seconds.

Explore how Java parallel streams create multiple threads to speed up work, how parallel differs from sequential streams, and when to use find any versus find first in parallel processing.

Understand that a stream cannot be reused after a terminal operation; storing it in a variable still allows only one terminal operation because the stream opens only when it runs.

Explore creating streams from lists, sets, maps, arrays, or multiple variables, using stream and stream off, then find the smallest value with a natural-order comparator.

Explain how to use optional properly in Java 8 and why returning an optional prevents null pointer exceptions; demonstrate finding the smallest of three strings with optional and present checks.

Explore comparator and comparing in Java streams to sort custom types, like a student with name, score, and height, by a key function; learn min and max with optional results.

Learn how to sum a list of integers with Java streams, why there is no built-in sum for streams of reference types, and how to handle lambda variable capture.

Learn how stream reduce combines a collection into one object using a lambda, shown with summing numbers, and why boxing to wrapper integers makes this approach inefficient for large data.

Convert a list of integers to an int stream using mapToInt to access primitive operations like sum and average, and understand the difference between stream of Integer and IntStream.

Explore Java primitive streams—int, long, and double—and how to map to int, long, or double with mapToInt/Long/Double, and box back to a stream of integers, including sum, average, min, max.

Explain switching between int and long streams, show that narrowing a long to int triggers a compilation error, and require an explicit cast to confirm the conversion.

Learn how to replace a traditional for loop with IntStream constructs using IntStream.range and IntStream.rangeClosed, including printing hello world multiple times and understanding inclusive versus exclusive bounds.

Explore how Java 8 introduces default methods in interfaces to add implementations without breaking existing code, using a custom list example and a consumer-based for-each.

Streams serve as a lazy data-flow channel, not storage, enabling chained intermediate operations and a terminal call, with collectors, grouping, primitive streams, and lambdas.

Engage in exercise-based practice to reinforce concepts learned so far by watching the lecture, attempting the task, and moving to the next lecture for the solution if needed.

Read a large first names file with files.readAllLines, then use streams to count names starting with h and b, collect c-starting names containing s, and sum chars of m-starting names.

Practice Java lambda and streams by processing a first names file: filter names by starting letters, trim and map to length, then sum character counts.

Use java lambda and streams to replace hyphens with spaces, collect names into a list, and find the longest name by length using a comparator with natural and reverse order.

Process first names in a stream by replacing minus with spaces, collecting to a list, and identify the longest name by length using a comparator.

Implement a page object with two methods—select the minimum price row and get the status—and drive a test to verify the minimum price row is selected on a price list.

Create a page object for the price table, locate rows with a css selector, determine the minimum price from the third column, and select its radio button then verify.

Finish the price table page object and create a test to select the minimum price row and verify its status. Implement the get status method to trim text.

Master hoverable multi-level dropdown automation using Java lambdas and streams, implementing actions.moveToElement to navigate nested menus, all within a test class without a page object, driven by a data provider.

Implement a hoverable dropdown selection by parsing link text, splitting the path into items, trimming, mapping to By.linkText locators, finding elements, and using Actions.moveToElement(...).perform() to hover and select.

Automate payment screen testing by covering free, partial, and discount promo codes with valid and invalid credit cards. Create a page object and one test class to validate these scenarios.

Build and interact with a payment screen page object using WebDriver in a Selenium framework, including applying promo codes, entering credit card details, and checking purchase status.

Explore how to model payment screen testing with java lambdas, creating reusable consumer actions for coupons and credit cards, and chain them to validate buy outcomes.

Learn Java 9’s architectural changes, garbage collection improvements, and API deprecations; explore stream API enhancements, factory methods for list, set, and map, and JShell for test automation.

Learn how Java 9's takeWhile on streams stops processing when a condition fails, offering a do-while style flow; compare with filter and limit using a list and collect to list.

Demonstrates how stream takeWhile works in Java with a numbers example, showing early termination when the condition fails while guiding proper Java nine-plus project setup.

Explore dropWhile in Java streams, the opposite of takeWhile, as an intermediate operation that drops elements while a condition holds, then returns the rest, unlike limit or skip.

Explore immutable lists in Java: before Java 9, lists like new ArrayList or Arrays.asList allowed mutation and nulls; Java 9's List.of creates unmodifiable, null-free lists with no post-creation modification.

Explore the unmodifiable set implementation in Java 9, filter a string set with streams, and collect to a new set, noting no mutation and no guaranteed order.

Discover immutable maps as key-value collections, learn how to initialize a constant map with Java 9 factory methods to prevent mutation, and apply this approach to driver configurations.

Use JShell in Java 9+ to interactively test Java code like a console, printing hello world and performing quick calculations without building a full class.

Learn to launch Chrome driver in jshell by configuring Selenium jars, setting classpath, and driving a browser to interact with elements and navigate pages.

Master how to exit jshell by typing slash exit and recognize the built-in goodbye message as confirmation.

Explore Java 9 stream updates with takewhile and dropwhile, showing predicates driving subsets and empties; review immutable collection factory methods for list, set, and map vs mutable array list.

Discover Java ten features, including local type inference and enhanced collectors API with unmodifiable lists and sets, and learn the six-month release cycle shaping modern Java development.

Var enables local type inference inside a method, inferring from the right hand side; declare and define in the same line. Do not use var for fields, parameters, or returns.

Understand that var is not a reserved keyword in Java and enables local type inference. Use backward compatibility to allow var as a local variable name, not for instance variables.

Avoid using var for lambda expressions, because the left-hand side type defines the functional interface and return type. Without that context, Java cannot infer the lambda.

Clarify how var can be used in lambda declarations and that a multi-line lambda serves as a method body, with explicit types or var allowed in specific contexts.

Explain how var interacts with generics in lists, showing the diamond operator on the right preserves integer type, while using var can widen to objects and trigger compile errors.

Learn collectors API changes, including unmodifiable list and set creation, using var and stream collect, and the move from mutable to immutable lists.

understand local type inference (var) and its use inside method bodies, plus its limitations for generics, parameters, return types, and lambdas; explore unmodifiable lists and sets in the collectors API.

Upgrade from Java 8 to Java 11 or newer and explore Java 11 features, including var in lambda parameters and the Optional isEmpty method, plus improved string APIs.

Learn how the string isBlank and isEmpty methods differ in Java, with isBlank treating whitespace as blank and isEmpty checking for zero length, introduced alongside Java 11 enhancements.

Explore Java 11's new string lines method, which returns a stream of strings split by newline characters, and connect it to a list or print the results.

Learn how the new string repeat method works by repeating a string multiple times, with practical examples for printing twice, repeating five times, and alignment tasks.

Explore how Java 11 adds the strip method to remove whitespace, including Unicode characters, and understand strip leading and trailing behavior.

Learn to write and read files in Java using the updated Files API, including writeString and readString, with absolute path handling and exception management.

See how the optional isEmpty method helps handle absent results in Java streams from a find first over numbers greater than five, returning an empty optional instead of null.