O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Java 8 Lambda Expressions and Streams

Video Description

6+ Hours of Video Instruction

Overview

Java 8 Lambda Expressions and Streams LiveLessons, 2nd Edition, covers the most important new features introduced in Java 8. The video training is presented by Marty Hall, a bestselling author, world-renowned instructor, and president of the training company coreservlets.com.

If you are comfortable with previous Java versions and want to learn the new Java 8 features as quickly as possible, continue on: You are in the right place. If, however, you are new to Java and want learn the full range of Java programming, but in the context of the latest version (Java 8), please see the video Learning Modern Java: A Crash Course Using Java 8 LiveLessons instead.

Description

This LiveLessons video explains the syntax and usage of Java 8 lambda expressions, shows the prebuilt functions, covers streams thoroughly, describes best practices for the use of parallel operations, provides examples of the types of applications to which lambdas and streams are well suited, and shows how applying the power of streams can dramatically simplify file I/O.

The final version of Java 8 was released in 2014, and it is by far the most significant upgrade to the Java programming language since at least 2004, probably since Java’s inception. In general, Java 8's high-level goals were to make code more flexible, to better use multiple cores, and to more easily deal with large data sets. Specifically, there are four main reasons that it is important for existing Java programmers to know the new Java 8 features:

  • More flexible and reusable code (thanks to lambdas). Lambda expressions in Java 8 are a way of representing "functions," and their judicious use can make your code significantly more adaptable and reusable.
  • Convenience (thanks to high-level Stream methods). Streams are wrappers around collections or other data sources that use lambda expressions pervasively. They support many convenient and high-performance operations that use lambdas, including "map," "reduce," "filter," and "forEach." These methods make many types of code much simpler to write compared to the clunky and low-level Collection methods.
  • Faster and more memory-efficient code (thanks to lazy evaluation and automatic parallelization). Streams support lazy evaluation, so if you map firstName over Employees, filter ones that start with "P," then choose the first, it really only maps and filters until the first match. Streams can also be designated as parallel, so that the operations are automatically done in parallel, without any explicit multithreading code.
  • Adapt to the times. Others will be using lambdas and streams because they are standard parts of Java SE as of 2014. So, you have to learn the Java 8 features simply to be able to use and modify others’ code. Besides, once you get a taste of their power, you will want to use the new features frequently.

The source code repository for this LiveLesson can be downloaded from http://www.coreservlets.com/java-8-tutorial. This site contains the complete source code for all examples in the video, as well as exercises and exercise solutions for each topic.

Finally, you can contact the author directly at hall@coreservlets.com with questions or suggestions or to inquire about customized training courses on Java EE and JavaScript topics to be held onsite at your organization.

About the Instructor

Marty Hall is president of coreservlets.com, a training and consulting company focusing on server-side Java technology, Android development, and rich Internet apps with Ajax. In addition to long Java development and consulting experience, Marty has an extensive background in teaching and training, having given training courses on Java 8, JSF 2, PrimeFaces, Android, JavaScript, jQuery, and other Java EE topics in dozens of U.S. venues and nine other countries.

A popular and entertaining speaker, Marty has spoken at conferences and user groups around the world, including Comdex, the Web 2.0 Expo, and five times at JavaOne. Marty is also adjunct faculty in the Johns Hopkins University part-time graduate program in Computer Science, where he directs the Java and Web-related concentration areas.
Marty is also the lead author of six popular Java EE books from Pearson, including Core Servlets and JSP, and is the coauthor of the upcoming JSF 2.3 edition of Core JSF.
You can see more details on Marty's bio page.

Skill Level

  • Intermediate to Advanced

What You Will Learn

  • Syntax of lambda expressions
  • How lambdas can make your code more flexible and reusable
  • Technologies that support lambdas: the @FunctionalInterface annotation, method references, lambda scoping rules, effectively final local variables, and higher-order functions
  • Lambda building blocks from the java.util.function package
  • Using static and default methods in Java 8 interfaces
  • Building streams from arrays, lists, and individual entries
  • Outputting streams into arrays or lists
  • Core stream methods: map, filter, forEach, and so forth
  • The new Optional class
  • Lazy evaluation and short-circuit stream operations
  • Specialized streams for dealing with numbers
  • Reduction operations: reduce, min, max, sum, average
  • Grouping stream elements: fancy uses of collect
  • Parallel streams: syntax and best practices
  • Infinite (unbounded) streams
  • Supporting Java 8 features: interfaces with concrete methods and the Optional class
  • File I/O in Java 8: applying the power of streams

Who Should Take This Course

Course Requirements

  • This LiveLessons video assumes that you have a medium to high amount of experience with earlier Java versions. It covers only the new features of the language that were added in Java 8. However, no previous experience with functional programming is required.

Lesson 1: Installation, Setup, and Quick Review of Supporting Topics
Lesson 1 shows you where to get the Java development kit and the official API documentation and how to create and execute Java programs in the Eclipse development environment. It also provides a quick review of pre-lambda handlers and building generic methods and classes.

Lesson 2: Lambda Expressions in Java 8—Part 1: Basics
Lesson 2 is the first of four lessons on lambda expressions. Lambdas are Java's way of representing functions. The lesson introduces lambda expressions and illustrates how their use can make your code more flexible and reusable. The lesson closes with two examples of applications that would be difficult and cumbersome without lambdas but that are relatively simple and short with them. The first is a numerical integration routine and the second is a reusable tool for collecting performance-timing results.

Lesson 3: Lambda Expressions in Java 8—Part 2
Lesson 3 covers four topics: the @FunctionalInterface annotation, method references, lambda variable scoping rules, and the rules regarding effectively final local variables. The lesson shows you how the use of @FunctionalInterface improves the internal implementation of the previous numerical-integration and timing applications and how method references make it simpler to use the numerical integration code.

Lesson 4: Lambda Expressions in Java 8—Part 3: Lambda Building Blocks in java.util.function
Lesson 4 looks at the pre-built functions in the java.util.function package. The lesson starts with the simply typed versions and shows how using one of them can shorten numerical-integration code. It then looks at five generically typed versions: Predicate, Function, Consumer, Supplier, and BinaryOperator. Most Java developers are not used to thinking about functional programming, so this lesson shows how applying functions can make certain applications shorter, simpler, easier to maintain, and more reusable.

Lesson 5: Lambda Expressions in Java 8—Part 4
Lesson 5 discusses two features of Java interfaces: default methods and static methods. It then uses this idea to improve the previous application that collected timing information. The second half of the lesson illustrates the power that comes from having methods that return lambdas, known as higher order functions.

Lesson 6: Streams in Java 8—Part 1
Lesson 6 is the first of three lessons on streams. It provides an overview of streams and explains their benefits. It then shows you how to create streams and output them into standard Java. It also explains data structures and four of the most important stream methods: forEach, filter, map, and findFirst. The lesson closes with a discussion of lazy evaluation and shows you how it can dramatically improve data processing performance.

Lesson 7: Streams in Java 8—Part 2
Lesson 7 starts out by discussing IntStream and DoubleStream, which are specializations of streams for dealing with numbers. It then looks in great detail at reduction operations: operations that combine stream values to produce a single result. The lesson starts out with simple ones like min, max, and sum and then finishes with the general-purpose reduce method. Finally, it discusses other stream methods, such as limit, skip, sorted, and anyMatch.

Lesson 8: Streams in Java 8—Part 3
Lesson 8 starts off by looking at fancy ways to output, partition, or group streams. It then explains how to use parallel streams—one of the most powerful stream features—and gives a number of examples where parallel streams do or do not work effectively. The lesson closes with an explanation of so-called "infinite" streams: streams that have no preset size but rather use a generator function to build the elements as they are needed.

Lesson 9: Simplified File I/O—Applying the Power of Streams in Java 8
Lesson 9 looks at File I/O. It starts by explaining both file reading and file writing, but in particular, it shows how applying the power of streams can dramatically simplify reading and processing files and folders. Specifically, it illustrates why the new Files.lines method is such a huge improvement over alternatives available in earlier Java versions.

About LiveLessons Video Training

The LiveLessons Video Training series publishes hundreds of hands-on, expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. This professional and personal technology video series features world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, IBM Press, Pearson IT Certification, Prentice Hall, Sams, and Que. Topics include: IT certification, programming, Web development, mobile development, home and office technologies, business and management, and more. View all LiveLessons on InformIT at: http://www.informit.com/livelessons.

Table of Contents

  1. Introduction
    1. Java 8 Lambda Expressions and Streams: Introduction 00:06:53
  2. Lesson 1: Installation, Setup, and Quick Review of Supporting Topics
    1. Topics 00:00:43
    2. 1.1 Getting Started with Java 8 00:03:33
    3. 1.2 Java 8 References 00:00:50
    4. 1.3 Quick Review of Pre-Lambda Handlers 00:14:07
    5. 1.4 Quick Review of Building Genericized Methods and Classes 00:08:05
    6. Summary 00:01:57
  3. Lesson 2: Lambda Expressions in Java 8—Part 1: Basics
    1. Topics 00:01:08
    2. 2.1 Motivation and Overview 00:10:59
    3. 2.2 Lambdas: Most Basic Form 00:10:55
    4. 2.3 Type Inferencing 00:04:44
    5. 2.4 Expression for Body: Implied Return Values 00:08:25
    6. 2.5 Omitting Parens 00:03:43
    7. 2.6 Summary: Making Lambdas More Succinct 00:03:58
    8. 2.7 Example: Numerical Integration 00:05:15
    9. 2.8 Making a Reusable Timing Utility 00:04:38
    10. 2.9 A Few More Samples 00:01:48
    11. Summary 00:03:52
  4. Lesson 3: Lambda Expressions in Java 8—Part 2
    1. Topics 00:00:44
    2. 3.1 The @FunctionalInterface Annotation 00:05:19
    3. 3.2 Method References 00:24:08
    4. 3.3 Lambda Variable Scoping in Lambdas 00:04:39
    5. 3.4 Effectively Final Local Variables 00:05:20
    6. Summary 00:02:13
  5. Lesson 4: Lambda Expressions in Java 8—Part 3: Lambda Building Blocks in java.util.function
    1. Topics 00:00:53
    2. 4.1 Overview: Lambda Building Blocks 00:08:47
    3. 4.2 Simply-Typed Building Blocks 00:04:58
    4. 4.3 Generic Building Blocks: Predicate 00:04:13
    5. 4.4 Generic Building Blocks: Function 00:08:48
    6. 4.5 Other Generic Building Blocks 00:08:13
    7. Summary 00:01:54
  6. Lesson 5: Lambda Expressions in Java 8—Part 4
    1. Topics 00:00:49
    2. 5.1 Java 8 Interfaces: Static Methods 00:05:26
    3. 5.2 Java 8 Interfaces: Default Methods 00:05:39
    4. 5.3 Resolving Conflicts with Default Methods 00:04:03
    5. 5.4 Higher Order Functions: Methods that Return Functions 00:02:19
    6. 5.5 Higher Order Functions in Predicate 00:04:46
    7. 5.6 Higher Order Functions in Function 00:07:29
    8. 5.7 Higher Order Functions in Consumer 00:03:18
    9. 5.8 Higher Order Functions in Your Own Code 00:04:18
    10. Summary 00:04:40
  7. Lesson 6: Streams in Java 8—Part 1
    1. Topics 00:00:45
    2. 6.1 Overview of Streams 00:11:28
    3. 6.2 Getting Standard Data Structures Into and Out of Streams 00:11:38
    4. 6.3 Core Stream Methods: Overview 00:06:22
    5. 6.4 forEach: Calling a Lambda on Each Element of a Stream 00:09:14
    6. 6.5 map: Transforming a Stream by Passing Each Element Through a Function 00:07:34
    7. 6.6 filter: Keeping Only the Elements that Pass a Predicate 00:04:06
    8. 6.7 findFirst: Returning the First Element of a Stream while Short-Circuiting Earlier Operations 00:10:45
    9. 6.8 Lazy Evaluation 00:09:07
    10. Summary 00:02:32
  8. Lesson 7: Streams in Java 8—Part 2
    1. Topics 00:00:44
    2. 7.1 Operations that Limit the Stream Size: limit, skip 00:02:17
    3. 7.2 Operations that Use Comparisons: sorted, min, max, distinct 00:05:40
    4. 7.3 Operations that Check Matches: allMatch, anyMatch, noneMatch, count 00:02:38
    5. 7.4 Number-Specialized Streams 00:08:00
    6. 7.5 The reduce Method and Related Reduction Operations 00:09:00
    7. Summary 00:02:20
  9. Lesson 8: Streams in Java 8—Part 3
    1. Topics 00:00:54
    2. 8.1 Grouping Stream Elements: Fancy Uses of collect 00:10:09
    3. 8.2 Parallel Streams 00:14:31
    4. 8.3 Infinite (Unbounded On-the-Fly) Streams 00:16:25
    5. Summary 00:02:01
  10. Lesson 9: File I/O Basics: Treating Files as Streams
    1. Topics 00:00:25
    2. 9.1 More on try/catch Blocks 00:10:00
    3. 9.2 Paths 00:05:48
    4. 9.3 File Reading: Overview 00:10:46
    5. 9.4 File Reading: First Variation 00:17:32
    6. 9.5 Simple File Writing 00:03:19
    7. 9.6 Faster and More Flexible File Writing 00:04:03
    8. 9.7 Exploring Folders 00:06:44
    9. Summary 00:02:49
  11. Lesson 10: Advanced File I/O: Making Code More Flexible by Using Lambdas and Generic Types
    1. Topics 00:00:27
    2. 10.1 File Reading: Second Variation 00:08:27
    3. 10.2 File Reading: Third Variation 00:11:17
    4. 10.3 File Reading: Fourth Variation 00:05:12
    5. 10.4 Combining Predicates 00:13:20
    6. Summary 00:03:08
  12. Summary
    1. Java 8 Lambda Expressions and Streams: Summary 00:01:09