by Raoul-Gabriel Urma, Mario Fusco, Alan Mycroft | Released August 2014 | ISBN: None

"A great and concise guide to what's new in Java8, with plenty of examples to get you going in a hurry." Jason Lee, Oracle Java 8 in Action is a clearly written guide to the features of Java 8. It begins with a practical introduction to lambdas, using real-world Java code. Next, it covers the new Streams API and shows how you can use it to make collection-based code radically easier to understand and maintain. It also explains other major Java 8 features including default methods, Optional, CompletableFuture, and the new Date and Time API. With Java 8's functional features you can now write more concise code in less time, and also automatically benefit from multicore architectures. It's time to dig in! Inside: How to use Java 8's powerful features Writing effective multicore-ready applications Refactoring, testing, and debugging Adopting functional-style programming Quizzes and quick-check questions This book/course is made for programmers familiar with Java and basic OO programming. Raoul-Gabriel Urma is a software engineer, speaker, trainer, and PhD candidate at the University of Cambridge. Mario Fusco is an engineer at Red Hat and creator of the lambdaj library. Alan Mycroft is a professor at Cambridge and cofounder of the Raspberry Pi Foundation. The best guide to Java8 that will ever be written! William Wheeler, ProData Computer Systems The new Streams API and lambda examples are especially useful. Steve Rogers, CGTek, Inc. A must-have to get functional with Java 8. Mayur S. Patil, MIT Academy of Engineering NARRATED BY EZRA SIMELOFF Show and hide more

1. PART 1: FUNDAMENTALS
   • Chapter 1. Java 8: why should you care? 00:09:21
   • Chapter 1. Java’s place in the programming language ecosystem 00:08:40
   • Chapter 1. Passing code to methods with behavior parameterization 00:07:42
   • Chapter 1. Functions in Java 00:07:20
   • Chapter 1. Passing code: an example 00:05:01
   • Chapter 1. Streams 00:09:08
   • Chapter 1. Default methods 00:10:13
   • Chapter 2. Passing code with behavior parameterization 00:07:54
   • Chapter 2. Behavior parameterization 00:06:30
   • Chapter 2. Tackling verbosity 00:09:38
   • Chapter 3. Lambda expressions 00:07:13
   • Chapter 3. Where and how to use lambdas 00:08:21
   • Chapter 3. Putting lambdas into practice: the execute around pattern 00:06:28
   • Chapter 3. Using functional interfaces 00:07:20
   • Chapter 3. Type checking, type inference, and restrictions 00:09:38
   • Chapter 3. Method references 00:08:48
   • Chapter 3. Putting lambdas and method references into practice! 00:09:28
   • Chapter 3. Similar ideas from mathematics 00:05:19
2. PART 2: FUNCTIONAL-STYLE DATA PROCESSING
   • Chapter 4. Introducing streams 00:08:08
   • Chapter 4. Getting started with streams 00:06:25
   • Chapter 4. Streams vs. collections 00:09:18
   • Chapter 4. Stream operations 00:06:04
   • Chapter 5. Working with streams 00:05:01
   • Chapter 5. Mapping 00:06:32
   • Chapter 5. Finding and matching 00:06:15
   • Chapter 5. Reducing 00:11:24
   • Chapter 5. Putting it all into practice 00:08:52
   • Chapter 5. Putting numerical streams into practice: Pythagorean triples 00:05:57
   • Chapter 5. Building streams 00:07:45
   • Chapter 5. Streams from functions: creating infinite streams! 00:06:41
   • Chapter 6. Collecting data with streams 00:08:47
   • Chapter 6. Reducing and summarizing 00:07:27
   • Chapter 6. Generalized summarization with reduction 00:11:01
   • Chapter 6. Grouping 00:04:55
   • Chapter 6. Collecting data in subgroups 00:07:29
   • Chapter 6. Partitioning 00:05:29
   • Chapter 6. The Collector interface 00:11:24
   • Chapter 6. Developing your own collector for better performance 00:09:49
   • Chapter 7. Parallel data processing and performance 00:07:46
   • Chapter 7. Measuring stream performance 00:06:29
   • Chapter 7. Using parallel streams correctly 00:07:32
   • Chapter 7. The fork/join framework 00:09:00
   • Chapter 7. Work stealing 00:03:41
   • Chapter 7. Spliterator 00:03:35
   • Chapter 7. Implementing your own Spliterator 00:10:24
3. PART 3: EFFECTIVE JAVA 8 PROGRAMMING
   • Chapter 8. Refactoring, testing, and debugging 00:08:14
   • Chapter 8. From imperative data processing to Streams 00:06:16
   • Chapter 8. Refactoring object-oriented design patterns with lambdas 00:06:11
   • Chapter 8. Observer 00:07:11
   • Chapter 8. Testing lambdas 00:10:14
   • Chapter 9. Default methods 00:07:57
   • Chapter 9. API version 2 00:08:39
   • Chapter 9. Usage patterns for default methods 00:06:56
   • Chapter 9. Resolution rules 00:10:32
   • Chapter 10. Using Optional as a better alternative to null 00:06:26
   • Chapter 10. Problems with null 00:04:50
   • Chapter 10. Introducing the Optional class 00:07:02
   • Chapter 10. Chaining Optional objects with flatMap 00:08:27
   • Chapter 10. Default actions and unwrapping an optional 00:07:26
   • Chapter 10. Practical examples of using Optional 00:09:10
   • Chapter 11. CompletableFuture: composable asynchronous programming 00:11:52
   • Chapter 11. Implementing an asynchronous API 00:09:28
   • Chapter 11. Make your code non-blocking 00:08:40
   • Chapter 11. Using a custom Executor 00:05:26
   • Chapter 11. Pipelining asynchronous tasks 00:10:02
   • Chapter 11. Combining two CompletableFutures—dependent and independent 00:05:15
   • Chapter 11. Reacting to a CompletableFuture completion 00:08:01
   • Chapter 12. New Date and Time API 00:08:12
   • Chapter 12. Instant: a date and time for machines 00:04:43
   • Chapter 12. Manipulating, parsing, and formatting dates 00:10:06
   • Chapter 12. Working with different time zones and calendars 00:07:35
4. PART 4: BEYOND JAVA
   • Chapter 13. Thinking functionally 00:09:21
   • Chapter 13. What’s functional programming? 00:08:04
   • Chapter 13. Referential transparency 00:10:22
   • Chapter 13. Recursion vs. iteration 00:07:15
   • Chapter 14. Functional programming techniques 00:09:04
   • Chapter 14. Persistent data structures 00:10:50
   • Chapter 14. Lazy evaluation with streams 00:05:39
   • Chapter 14. Your own lazy list 00:07:31
   • Chapter 14. Pattern matching 00:07:34
   • Chapter 14. Miscellany 00:09:34
   • Chapter 15. Blending OOP and FP: comparing Java 8 and Scala 00:08:02
   • Chapter 15. Basic data structures: List, Set, Map, Tuple, Stream, Option 00:10:28
   • Chapter 15. Functions 00:09:15
   • Chapter 15. Classes and traits 00:04:39
   • Chapter 16. Conclusions and where next for Java 00:11:27
   • Chapter 16. What’s ahead for Java? 00:08:31
   • Chapter 16. Richer forms of generics 00:09:12
   • Chapter 16. Value types 00:08:44
Show and hide more