- Copyright 2016
- Edition: 2nd
- ISBN-10: 0-13-438357-5
- ISBN-13: 978-0-13-438357-6
6+ Hours of Video Instruction
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.
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.
Who Should Take This CourseCourse Requirements
- 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
Table of ContentsLesson 1: Installation, Setup, and Quick Review of Supporting Topics
- 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 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