Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Lambdas in Java - From Zero to Hero

Name: Lambdas in Java - From Zero to Hero
Rating: 4.3 (320 reviews)

Master Java 8 Lambdas & Streams — Functional Interfaces, Collectors, Optional, Parallel Streams

Created byAjay Iyengar

Last updated 8/2025

English

What you'll learn

Starting from the basics, gain in-depth knowledge about Lambdas and Streams using lots of examples
Explore a variety of functional interfaces
Understand how Lambda expressions are implemented in the JDK by looking at the byte code
Complete understanding of Method references, Optional API, Comparator
Explore numerous methods in the Stream API and the Collectors class
Understand Reduction, flatMap, Parallel Streams, and when to use them
Learn "good" coding practices as we discover these topics by a professional Java developer who has been working with the language for 14 years
With plenty of exercises to solve, confidently demonstrate your understanding of Lambdas and Streams to future employers

Course content

13 sections • 167 lectures • 18h 15m total length

Programming is an Art: Difference between Verbose and Concise1:33
Verbose code before Java 8: First solution to Problem one4:53
Concise code starting Java 8: Second solution to Problem one2:13
Verbose code before Java 8: First solution to Problem two2:54
Concise code starting Java 8: Second solution to Problem two1:45
Conclusion - Why you must learn Lambdas and Streams introduced in Java 81:00
Structure of the course3:31
The "What, Why, How" approach in the course & Prerequisites1:52
About the exercises4:02
Downloading the code1:40

Section Introduction3:05
Tackling requirements in a simple Employee Management System and solving them6:21
Code refactoring - Improving on the first solution4:49
Copy Pasting solutions - Tackling a couple of more requirements8:05
Code walkthrough of the solutions so far8:17
Introduction to the Strategy pattern3:22
Understanding the Strategy pattern7:31
Code walkthrough - Implementing the Strategy pattern8:51
Introduction to anonymous classes4:22
Code refactoring - Replacing the Strategy pattern with anonymous classes8:34
Exercise one - Simulate a simple payment process for a shopping cart0:54
Exercise two - Payment process for a shopping cart using the Strategy pattern0:35

Section Introduction1:28
Writing our first Lambda expression3:50
Understanding Lambda expressions9:45
Understanding the relation between lambda expressions and a functional interface7:22
Code refactoring - Replacing an anonymous class with a lambda expression8:35
Code refactoring - Understanding the concept of higher-order functions9:19
Replacing multiple lines of code by using the extract method technique3:15
Exercise - Lambda expressions1:02

Section Introduction2:14
Introduction to the Predicate functional interface1:57
Code refactoring - Applying the Predicate interface6:12
Code - Combining multiple predicates with the Predicate functional interface7:04
Exploring default methods11:37
Exploring the removeIf method, a default method11:18
Introduction to the Supplier functional interface14:59
Code - Implementing the factory pattern using the Supplier functional interface10:47
Code - Understanding ThreadLocal and the Supplier functional interface15:43
Understanding how Java Logging API utilizes Supplier functional interface4:02
Introduction to the Consumer functional interface2:10
Code - Exploring the Consumer functional interface14:27
Code - Understanding the 'andThen' method in the Consumer functional interface6:51
The 'forEach' method and the Consumer functional interface3:54
Code - Understanding how the BiConsumer functional interface is used in the JDK11:48
Code - Introduction to the functional interface, Function13:20
Code - Exploring the 'andThen' method in the Function interface.8:45
Code - Difference between 'andThen' and 'compose' method in Function interface7:53
Code - Applying 'Predicate' and 'Function' together17:27
Code - Understanding the 'computeIfAbsent' method16:01
Summary of Functional interfaces9:02
Exercise - Functional Interface0:42

Section Introduction1:41
Peek at the byte code, challenges of running a dynamically typed language on JVM15:50
What is invokedynamic and what problem did it solve?6:52
Laying the groundwork - Understanding MethodHandles7:19
Putting it all together - Lambda expressions, MethodHandles, and invokedynamic17:18
Deep dive into LambdaMetaFactory, capturing, and non-capturing Lambdas.11:09
Translation of Lambda expressions and performance3:07

Section Introduction3:13
Understanding the concept of "Effectively final"10:16
Understanding lexical scope in Lambda expressions11:39
Finding an answer to the question - "Do Lambdas replace anonymous classes?"2:14
Code - Sorting employee objects using an anonymous class12:11
Code - Refactoring : Replacing the anonymous class with lambda expressions4:46
Code - Refactoring : Using the sort method from the List interface3:53
Code - Understanding comparing, thenComparing, and reversed from Comparator13:57
Code - Final Refactoring, using comparingInt method from Comparator7:30
Understanding Method references14:11
Code - Refactoring sorting methods to use method references12:58
Exercise 1 - Sorting a list of strings using Comparator0:13
Exercise 2 - Sorting a list of PremierLeagueTeam objects0:57

Section Introduction2:40
Introduction to stream, filter, and collect methods7:04
Code - Applying stream, filter, and collect using an example6:15
Understand what a stream is and where does this stream live4:31
Introduction to the 'map' method in the Stream API5:12
Code - Applying the 'map' method in an example4:55
Understanding the lazy nature of Streams7:06
Understanding data flow in a Stream pipeline8:43
Introduction to the sorted method in the Stream API6:08
Code - Applying 'sorted' functionality in an example8:21
A look at the nonNull method in the Objects class4:16
Introduction to the distinct method in the Stream API7:20
Code - Applying the 'distinct' method in an example6:59
Stateful vs. Stateless operations in a Stream pipeline6:13
Peeking into the sorted and distinct operations in the Stream pipeline15:55
Exercise - Perform basic Stream API operations around a mock movie database.1:01

Section Introduction3:29
Follow good coding practices - Return an empty list and not a null from a method5:08
Introduction to the Optional API7:07
Exploring the commonly used methods in the Optional class6:19
Understanding the design intention behind the Optional class7:49
Finding the first element of a stream and applying the Optional class7:35
Introduction to the 'map' and 'orElse' method in the Optional class10:51
Introduction to the orElse family of functions in the Optional class8:37
Introduction to the findAny method in the Optional class3:53
Code - Reading a file with lots of words and applying the findFirst and findAny8:49
A look at the anyMatch, allMatch, and noneMatch methods in the Stream API8:04
Introduction to the short-circuiting methods - limit and takeWhile10:13
Recommendations - Using the Optional class9:10
Understanding encounter order in a Stream pipeline9:41
Differences between Streams and Collections4:56
Exercise - Search Methods in the Stream API1:36

Section Introduction4:18
Understanding the concept of Reduction4:30
Why do we need a reduction and the importance of an identity in a reduction11:40
First glimpse of a parallel stream7:15
More examples of a reduce method6:13
Introduction to primitive specializations of streams9:21
Finding the sum of the elements in the Stream using the sum method3:33
Finding the count of elements in a Stream using the count method6:47
Finding the minimum and maximum element in a Stream using the min and max method8:25
Mutable reduction using the 'collect' method6:13
Code - Reading a file with a lot of words and applying the max method8:35
Code - Reading a file with a lot of words and applying the max and min method6:35
Code - Reading a file and applying the sum and count methods5:23
Exercise - Reduction operations0:31

Section Introduction - Part one5:34
Section Introduction - Part two5:18
Introduction to the domain and classes in this section - Football teams5:16
Grouping objects using an imperative style of coding9:18
Grouping objects using the declarative style of coding7:33
Collecting the number of input elements in a downstream collector5:28
Finding the sum using a mapper function in a downstream collector8:04
Partitioning the input elements of a stream4:16
Code - Applying the groupingBy method7:27
Code - Example of a multilevel groupingBy6:27
Code - Finding statistics in a single pass using IntSummaryStatistics7:06
Joining the elements of a stream using a collector4:51
Code - Mapping function in a downstream collector9:06
Code - How to partition and then group objects?5:08
Exercise - Using the Collectors class0:47

Requirements

Some (intermediate level) programming experience with Java
A computer with the latest JDK and an IDE
You need not have any experience with Lambdas and Streams since we start from the basics
Desire to learn while still enjoying a few jokes!

Description

Join the most comprehensive course that covers Lambdas and Streams introduced in Java 8.

There are lots of exercises (along with the solution) at the end of a section that will help you gain confidence.

Using numerous real-life examples, you will learn:

What the Strategy pattern is
What kinds of problems do Anonymous classes solve?
Why do we need Lambda expressions?
How can Lambda expressions help us in writing concise code?
What are higher-order functions?
Deep dive into how Lambda expressions are implemented behind the scenes and -
1. Understand how to look at byte code using javap
2. Understand the role of the invokedynamic byte code instruction
3. What are Method Handles
Commonly used functional interfaces like Predicate, Function, Supplier, Consumer, BiConsumer -
1. How and where to apply them?
2. How are they used internally in the JDK library?
Function composition
Method references
Explore the Comparator interface
Numerous methods in the Stream API like - filter, map, collect, sorted, distinct
Understanding what a stream is
Understanding the important characteristics of a stream
Optional API and the right way to use them
Short-circuiting operations in the Stream pipeline
Understand why we need Primitive Streams
Reduction operations in the Stream pipeline and the importance of identity in Reduction
Explore the Collectors API
Explore flatMap and other sources of creating Streams
Explore Parallel Streams -
1. What is Moore's law?
2. Why do we need Parallel streams?
3. When should we use Parallel streams?
4. What is the infrastructure behind the scenes when we use Parallel streams?
5. How does Reduction work in parallel streams?
6. Role of the Spliterator
Learn how to debug and visualize Java 8 Streams with Eclipse & Intellij

and more!

Students completing the course will have a solid, in-depth knowledge of writing concise code using many features that have truly revolutionized how we write code in Java.

Now includes a focused PDF guide on Java 8 Lambdas & Streams — with fresh examples, best practices, and a quick reference table for coding and interviews.

What if you have questions?

I offer full support, 7 days a week, answering any questions you have.

What version of Java should you use?

I am using Java 14 for all the demos since that is the latest version when recording this course. I would urge you to use the latest version of Java. However, the focus will be on Lambdas, Streams, and lots of other features introduced in Java 8 as mentioned above.

Who this course is for:

This course is for Java developers who want to get a solid understanding of Lambdas and Streams introduced in Java 8

Lambdas in Java - From Zero to Hero

What you'll learn

Explore related topics

Course content

Why should you learn Lambdas and Streams?10 lectures • 25min

Life before Lambdas12 lectures • 1hr 5min

Beginning our journey with Lambda expressions8 lectures • 45min

Exploring functional interfaces22 lectures • 3hr 18min

Deep dive - Understanding how Lambda expressions are implemented in Java7 lectures • 1hr 3min

Exploring Comparators, Method references, lexical scope13 lectures • 1hr 38min

Introduction to Streams by harnessing Lambdas16 lectures • 1hr 43min

Exploring Optional API and the short circuiting operations in the Stream API16 lectures • 1hr 53min

Exploring Reductions in the Stream Pipeline14 lectures • 1hr 29min

Exploring the Collectors API15 lectures • 1hr 32min

Requirements

Description

Who this course is for: