Java Programming, Lambda and more (Java 13, 12, 11, 10, 9,8)

Learn how java lambda expressions create anonymous functions with a parameter list, braces and an arrow, enabling compact implementations of functional interfaces with a single abstract method, using type inference.

Create a Java project, define a hello world interface with an abstract say hello method, then replace the traditional implementation with a lambda expression that prints hello world.

Demonstrate how lambda expressions simplify hello world, increment by 5, and string concatenation by inferring return types and reducing boilerplate, comparing traditional and lambda implementations.

Explore a Java 8+ runnable example by implementing an animal interface with and without lambda expressions, run threads to sum ten numbers, and print the result 45.

Demonstrates implementing a callable using a lambda expression to sum numbers from 0 to 5000, with two callables executed by an executor service and verifying total with a stream sum.

Explore Java functional interfaces defined by a single abstract method, with optional default and static methods, enabling backward compatibility and lambda expressions, including consumer, supplier, and predicate.

Explore the Java 8+ consumer functional interface, its accept method, and how it enables one-argument operations in functional programming with block statements through practical examples.

Explore Java8+ consumer functional interface usage with for each and lambda expressions to print instructors, names, and courses, and filter by years of experience and online courses.

Explore java eight+ specialized consumers: IntConsumer, LongConsumer, and DoubleConsumer that accept only specific numeric arguments, with examples showing their usage and printed results.

Introduce the BiConsumer functional interface in Java 8+, showing how it accepts two arguments, performs operations, and prints results without returning a value through practical two-argument examples.

Explore Java 8's BiConsumer functional interface by implementing examples that print instructor names and genders, list courses, and identify online instructors using lambda expressions.

Explore the Java predicate functional interface, its test method, and how to compose predicates with and, or, and negate for concise, reusable conditions.

Explore specialized predicates in Java: int, long, and double predicates with predicate examples. Create a class PredicateExample to define int, long, and double predicates, test values, and print outcomes.

Explore Java 8+ predicates and BiConsumer with a lambda example that filters online instructors by experience over ten years and prints each instructor's name and courses.

Explore the Java 8+ BiPredicate functional interface by building a two-argument predicate that checks online status and years of experience, and apply a corresponding consumer to print matching instructors.

This lecture introduces the Java function interface for functional programming, demonstrating apply, compose, and identity, with examples that map numbers to square roots and transform strings to lowercase then concatenate.

Apply the function interface to convert a list of instructors into a map of names to years of experience, using a lambda and a predicate for online courses.

Explore the BiFunction interface in Java, which takes two inputs and returns a result via apply, illustrating functional programming concepts with maps and predicates.

Explore the unary operator in Java, a specialized function where input and output share the same type. See int, long, and double variants, with apply and examples.

Explore the Java binary operator interface, a function interface that takes two values of the same type and returns a value of that type, with integer, long, and double specializations.

Explain the Java supplier interface, a no-argument function that returns a value via get, acting as a factory; implement and reuse a single supplier for tasks like generating random numbers.

Replace lambdas with method references in Java 8+ using the :: syntax, mastering static, instance, and constructor references. See examples converting square and lowercase methods and a predicate check.

Learn how to convert lambda expressions to method references in Java 8+ with practical examples, including predicates and static method references, and how to replace lambdas with method references.

Explore converting lambda expressions to method references in Java 8+ by refactoring a predicate into a static boolean method and using it to check greater than 10 years of experience.

Learn to use constructor references with a functional interface to instantiate objects, design an instructor factory interface with a matching abstract method, and implement the example.

Explore how lambda expressions share the scope of nested blocks, enforce effectively final constraints on local variables, and require class level or final-like variables for safe capture.

master real world bank transfers with java 8+ lambda expressions, using an account factory to create bank accounts and execute 20 parallel transfers with threads.

Discover how the Java 8 stream API adds a pipeline layer over collections, enabling map, filter, sort, collect, and reduce with lambda expressions and parallel processing.

Create a stream-based workflow to map instructor names to online courses using predicates for online status and years of experience, then collect and print the results.

Learn how Java streams use intermediate operators like filter and terminal operations like collect, and why a stream cannot be reused after creation, as you trace the pipeline.

Explore the key differences between collections and streams in Java, showing how streams derive from collections and support lazy, one-time traversal, while collections allow add and remove operations.

Debug stream operations in Java using two approaches: the trace and chain tool in the debugger, and the stream API's peek method, and observe elements through filter and collect steps.

Explore the map operation in streams to convert elements, map to new forms (like names to uppercase), and collect results into lists or sets while preserving order.

Learn how flatMap combines map and flatten operations to flatten a stream of instructor courses, collect results, and remove duplicates with a set.

Explore Java streams operations such as distinct, count, sorted, anyMatch, allMatch, and noneMatch to filter, remove duplicates, sort, and evaluate predicates on a list of courses.

Explore custom sorting with comparator in Java 8 and later, using streams to sort, collect results, and print in order or reverse order, with debugging steps.

Explain how the stream filter uses a predicate to lazily produce elements, with an example that sorts and prints instructors with more than ten years of experience.

Learn how Java streams reduce uses an identity and a binary operator to combine elements, including handling optional results and examples of sum and multiplication.

Learn to use streams and reduce to identify the instructor with the most years of experience. Handle optional results safely and refactor the code with a ternary operator.

Explore map, filter, and reduce on streams to calculate total years of instructor experience, filtering online courses and using Integer::sum for efficient aggregation.

Explore computing the maximum value from a list of integers using a Java stream and the reduce method, including optional result handling and identity-based reduction.

Learn to compute the minimum with java streams and the min operator, using optional results and reduce. See a 1–7 number list and compare identity usage and printing the minimum.

Explains Java streams limit and skip operations by taking the first n elements or skipping the first n elements, with a code example printing and collecting results from a list.

Explore Java streams by comparing findFirst and findAny, explaining optional results, determinism versus non-determinism, and how parallel streams can affect the chosen element.

Explore Java streams using the stream factory methods of, iterate, and generate to create finite and infinite streams from data, with seeds and suppliers.

Explore numeric streams in Java 8+ by examining streams of primitive integers and primitive doubles, and understand how these streams support efficient numeric processing.

This lecture introduces int streams in java 8+, showcasing techniques to generate integer streams: of, range, rangeClosed, iterate, generate, and random with practical examples.

Explore generating long streams in Java 8+, including even numbers from zero, random long values with a limit, and range and rangeClosed methods producing inclusive and exclusive sequences.

Explore Java 8 double streams by creating streams from literal values, generating with random values and limits, and converting sequences to double streams for printing and verification.

Learn how to use java stream aggregate functions, including sum, min, max, and average, by calculating over a 0 to 1000 numeric stream with optional results and printing the outcomes.

Explore boxing and unboxing in Java by converting primitives to wrapper objects and back, using lists and streams to collect, map, and sum numbers.

Explore java streams with mapToObj, mapToLong, and mapToDouble to transform elements into objects, longs, and doubles, illustrated by a brand name id class and random tokens.

Explore Java streams' joining collectors in Java 8 and later, using overloads with no delimiter, with a delimiter, and with prefix and suffix to concatenate input elements in encounter order.

Explore collectors counting in Java streams and compare it with stream count, revealing how counting supports downstream tasks like grouping by string length.

Demonstrate how the collectors mapping operator combines a function with a downstream collector to map elements and build groups, e.g., grouping by instructor years of experience and names.

Learn how Java 8+ minBy and maxBy collectors return optional minimal or maximal elements using a comparator, with practical downstream usage in stream operations.

Explore Java 8+ collectors like summingInt and averagingInt to compute sums and averages from streams, with an example averaging instructors' years of experience.

Explore how grouping by classifier in Java 8+ uses collectors.groupingBy to categorize strings and instructors by length, gender, and experience.

Explore the second overload of groupingBy with a classifier and downstream filtering. Group names by length with a contains-e filter; classify instructors as senior or junior, filtered by online courses.

Explore the Java 8+ groupingBy method, detailing classifier and downstream parameters, and implement a custom grouping by using a LinkedHashMap and HashMap in a stream.

Group instructors by online versus offline courses and compute the maximum years of experience using maxBy and minBy. Use collectingAndThen and summarizingInt to derive averages and summary statistics.

Explore partitioning by a predicate in Java streams using collectors.partitioningBy, returning a boolean map and a downstream collection, demonstrated with instructors' years of experience.