Modern Java in Action video edition

Video description

In Video Editions the narrator reads the book while the content, figures, code listings, diagrams, and text appear on the screen. Like an audiobook that you can also watch as a video.

"A comprehensive and practical introduction to the modern features of the latest Java releases with excellent examples!"
Oleksandr Mandryk, EPAM Systems

Manning's bestselling Java 8 book has been revised for Java 9 and 10! In Modern Java in Action, you'll build on your existing Java language skills with the newest features and techniques.

Modern applications take advantage of innovative designs, including microservices, reactive architectures, and streaming data. Modern Java features like lambdas, streams, and the long-awaited Java Module System make implementing these designs significantly easier. It’s time to upgrade your skills and meet these challenges head on!

Modern Java in Action connects new features of the Java language with their practical applications. Using crystal-clear examples and careful attention to detail, this book respects your time. It will help you expand your existing knowledge of core Java as you master modern additions like the Streams API and the Java Module System, explore new approaches to concurrency, and learn how functional concepts can help you write code that’s easier to read and maintain.

  • Thoroughly revised edition of Manning’s bestselling Java 8 in Action
  • New features in Java 8, Java 9, and beyond
  • Streaming data and reactive programming
  • The Java Module System
Written for developers familiar with core Java features.

Raoul-Gabriel Urma is CEO of Cambridge Spark. Mario Fusco is a senior software engineer at Red Hat. Alan Mycroft is a University of Cambridge computer science professor; he cofounded the Raspberry Pi Foundation.

My Java code improved significantly after reading this book. I was able to take the clear examples and immediately put them into practice.
Holly Cummins, IBM

Hands-on Java 8 and 9, simply and elegantly explained.
Deepak Bhaskaran, Salesforce

A lot of great examples and use cases for streams, concurrency, and reactive programming.
Rob Pacheco, Synopsys


Table of contents

  1. Part 1. Fundamentals
  2. Ch 1. Java 8, 9, 10, and 11: what’s happening?
    1. So, what’s the big story?
    2. Why is Java still changing?
    3. Stream processing
    4. Parallelism and shared mutable data
    5. Functions in Java
    6. Passing code: an example
    7. Streams
    8. Default methods and Java modules
    9. Other good ideas from functional programming
  3. Ch 2. Passing code with behavior parameterization
    1. Coping with changing requirements
    2. Behavior parameterization
    3. Tackling verbosity
    4. Real-world examples
  4. Ch 3. Lambda expressions
    1. Lambdas in a nutshell
    2. Where and how to use lambdas
    3. Putting lambdas into practice: the execute-around pattern
    4. Using functional interfaces
    5. Type checking, type inference, and restrictions
    6. Type inference
    7. Method references
    8. Putting lambdas and method references into practice
    9. Useful methods to compose lambda expressions
    10. Similar ideas from mathematics
  5. Part 2. Functional-style data processing with streams
  6. Ch 4. Introducing streams
    1. What are streams?
    2. Getting started with streams
    3. Streams vs. collections
    4. External vs. internal iteration
    5. Stream operations
  7. Ch 5. Working with streams
    1. Filtering
    2. Mapping
    3. Finding and matching
    4. Reducing
    5. Maximum and minimum
    6. Putting it all into practice
    7. Numeric streams
    8. Putting numerical streams into practice: Pythagorean triples
    9. Building streams
    10. Streams from functions: creating infinite streams!
    11. Overview
  8. Ch 6. Collecting data with streams
    1. Collectors in a nutshell
    2. Reducing and summarizing
    3. Generalized summarization with reduction
    4. Grouping
    5. Collecting data in subgroups
    6. Partitioning
    7. The Collector interface
    8. Putting them all together
    9. Developing your own collector for better performance
  9. Ch 7. Parallel data processing and performance
    1. Parallel streams
    2. Measuring stream performance
    3. Using parallel streams correctly
    4. The fork/join framework
    5. Best practices for using the fork/join framework
    6. Spliterator
    7. Implementing your own Spliterator
  10. Part 3. Effective programming with streams and lambdas
  11. Ch 8. Collection API enhancements
    1. Collection factories
    2. Working with List and Set
    3. Working with Map
    4. Remove patterns
    5. Improved ConcurrentHashMap
  12. Ch 9. Refactoring, testing, and debugging
    1. Improving code readability
    2. From lambda expressions to method references
    3. Refactoring object-oriented design patterns with lambdas
    4. Observer
    5. Testing lambdas
    6. Debugging
  13. Ch 10. Domain-specific languages using lambdas
    1. Domain-specific languages using lambdas
    2. A specific language for your domain
    3. Different DSL solutions available on the JVM
    4. Small DSLs in modern Java APIs
    5. Patterns and techniques to create DSLs in Java
    6. Function sequencing with lambda expressions
    7. Real World Java 8 DSL
    8. Spring Integration
  14. Part 4. Everyday Java
  15. Ch 11. Using Optional as a better alternative to null
    1. How do you model the absence of a value?
    2. Problems with null
    3. Introducing the Optional class
    4. Patterns for adopting Optionals
    5. Chaining Optional objects with flatMap
    6. Manipulating a stream of optionals
    7. Combining two Optionals
    8. Practical examples of using Optional
  16. Ch 12. New Date and Time API
    1. LocalDate, LocalTime, LocalDateTime, Instant, Duration, and Period
    2. Combining a date and a time
    3. Manipulating, parsing, and formatting dates
    4. Working with different time zones and calendars
  17. Ch 13. Default methods
    1. Default methods
    2. Evolving APIs
    3. Default methods in a nutshell
    4. Usage patterns for default methods
    5. Resolution rules
    6. Diamond problem
  18. Ch 14. The Java Module System
    1. The driving force: reasoning about software
    2. Why the Java Module System was designed
    3. Monolithic JDK
    4. Java modules: the big picture
    5. Developing an application with the Java Module System
    6. Working with several modules
    7. Compiling and packaging
    8. Module declaration and clauses
  19. Part 5. Enhanced Java concurrency
  20. Ch 15. Concepts behind CompletableFuture and reactive programming
    1. Concepts behind CompletableFuture and reactive programming
    2. Evolving Java support for expressing concurrency
    3. Executors and thread pools
    4. Other abstractions of threads: non-nested with method calls
    5. Synchronous and asynchronous APIs
    6. Reactive-style API
    7. Reality check
    8. The box-and-channel model
    9. CompletableFuture and combinators for concurrency
    10. Publish-subscribe and reactive programming
    11. Backpressure
    12. Reactive systems vs. reactive programming
  21. Ch 16. CompletableFuture: composable asynchronous programming
    1. Simple use of Futures
    2. Implementing an asynchronous API
    3. Making your code nonblocking
    4. Looking for the solution that scales better
    5. Pipelining asynchronous tasks
    6. Composing synchronous and asynchronous operations
    7. Combining two CompletableFutures: dependent and independent
    8. Reacting to a CompletableFuture completion
  22. Ch 17. Reactive programming
    1. The Reactive Manifesto
    2. Reactive at application level
    3. Reactive streams and the Flow API
    4. Creating your first reactive application
    5. Using the reactive library RxJava
    6. Creating and using an Observable
    7. Transforming and combining Observables
  23. Part 6. Functional programming and future Java evolution
  24. Ch 18. Thinking functionally
    1. Implementing and maintaining systems
    2. What’s functional programming?
    3. Referential transparency
    4. Recursion vs. iteration
  25. Ch 19. Functional programming techniques
    1. Functions everywhere
    2. Persistent data structures
    3. Using a functional approach
    4. Lazy evaluation with streams
    5. Your own lazy list
    6. Pattern matching
    7. Miscellany
  26. Ch 20. Blending OOP and FP: Comparing Java and Scala
    1. Introduction to Scala
    2. Basic data structures: List, Set, Map, Tuple, Stream, Option
    3. Functions
    4. Classes and traits
  27. Ch 21. Conclusions and where next for Java
    1. Review of Java 8 features
    2. CompletableFuture
    3. The Java 9 module system
    4. What’s ahead for Java?
    5. Richer forms of generics
    6. Value types
    7. Moving Java forward faster
  28. App A. Miscellaneous language updates
    1. Miscellaneous language updates
  29. App B. Miscellaneous library updates
    1. Collections
    2. Concurrency
    3. Arrays
  30. App C. Performing multiple operations in parallel on a stream
    1. Forking a stream
    2. Developing the ForkingStreamConsumer and the BlockingQueueSpliterator
  31. App D. Lambdas and JVM bytecode
    1. Anonymous classes

Product information

  • Title: Modern Java in Action video edition
  • Author(s): Raoul-Gabriel Urma, Mario Fusco, Alan Mycroft
  • Release date: September 2018
  • Publisher(s): Manning Publications
  • ISBN: None