View Schedule & Book More dates available

Next up:


Java 8 was the largest update to Java in it's history. Java 9 and beyond has brought us Reactive and Asynchronous programming. This isn't your parents' Java anymore. Modern Java has incorporated the best ideas from functional programming to help us write better, easier to read, more flexible code that scales to multicore. Join this hands-on Modern Java course and learn to write more flexible and concise code, using the latest practices and tools and cutting edge programming approaches.

Learn how to:

  • Get up to speed with lambda expressions.
  • Apply functional programming concepts and understand where this is an appropriate approach and where its not.
  • Introduce changes to the collections library such as Streams and the higher order functions such as map and filter.
  • Solve simple data processing problems with Collectors.

  • What the community says

    "Very good at teaching and presenting the syllabus, good at answering the questions"

    Delegate on 18th Jul 2019

    "Instructors had excellent domain knowledge, and explained adequately wherever necessary, as well as helping with ad-hoc questions."

    Syed, BMJ

    "Honestly the best course I've ever attended. Perfect balance of lectures and exercises."

    Aaron Graham, Unruly Group

    "Very knowledgeable and an engaging delivery style. Excellent exercises to complement the learning, well spread out to give a good balance between lecture/practical."

    Michael Funnell, Betfair

    "Entertaining and engaging presentation style, well prepared code demonstrations."

    Boris Morris, Anaplan

    About the Authors

    Richard Warburton

    Richard Warburton is an empirical technologist, solver of deep-dive technical problems and author of 'Java 8 Lambdas: Pragmatic Functional Programming'. He has worked as a developer in varied areas including Statistical Analytics, Static Analysis, Compilers and Networking. He is a leader in the London Java Community and runs OpenJDK Hackdays. Richard is also a known conference speaker, having talked at JavaOne, Devoxx, JFokus, DevoxxUK, Geecon, JAX London and Codemotion. Richard has obtained a PhD in Computer Science from The University of Warwick.

    Raoul-Gabriel Urma

    Raoul-Gabriel Urma is CEO and co-founder of Cambridge Spark, a leading learning community for data scientists and developers in the UK, as well as chairman and co-founder of Cambridge Coding Academy, a growing community of young coders and pre-university students. He is author of 'Java 8 in Action: Lambdas, Streams, and functional-style programming'.

    Thanks to our partners


    Day 1

    Lambda Expressions

  • Why Java 8?
  • Behaviour parameterisation
  • More flexible code
  • Anonymous classes
  • What is a lambda?
  • Syntax
  • Functional interfaces: where to use lambda expressions?
  • java.util.function
  • Refactoring/putting together exercise
  • Method references: firstclass
  • Functions in Java 8
  • Method references recipes
  • Type checking
  • Type inference
  • Using local variables


  • Collection Processing
  • What is a Stream?- Stream operations and patterns- Filtering
  • Mapping
  • Finding and Matching
  • Reducing
  • minBy/maxBy
  • Stream Optimization
  • The reduce pattern
  • Eager vs Lazy
  • Shortcircuiting and Loop FusionExercise: financial data processing (part 1)


  • Grouping and partitioning
  • Collection Operations
  • Collecting to lists and sets
  • Flexible Collection
  • Arithmetic collectors
  • Max/Min
  • Average/Count/Sum
  • Summary statistics
  • Advanced Queries
  • Beyond grouping and partitioning
  • Downstream collectorsExercise: financial data processing (part 2)

    Mutable Reduction

  • Extending the reduce pattern
  • Reducing collector

    Day 2

    Easy Data Parallelism

  • What is Data Parallelism?
  • Why is this important?
  • Parallelising your streams
  • Parallel Gotchas
  • Misuse of reduce
  • Don’t use Locks
  • Danger of mutability
  • Decomposing performance

    Testing & Debugging Lambda Expressions

  • Unit testing lambda expressions
  • Debugging with laziness
  • Stack tracesPractical: Hands on Debugging

    Default and static methods on interfaces

  • Motivation for default methods
  • Static methods in interface
  • Useful default methods
  • Patterns for default methods
  • Resolution rules

    Enhanced Design with Lambdas

  • Execute around: resource handling
  • Deferred execution: Logging
  • Design patterns
  • Command
  • Strategy
  • Observer
  • Template
  • Factory
  • Processing pipeline

    Date & Time in Java 8

  • The problem with existing date and time libraries
  • The core classes: LocalDate/LocalTime
  • Common API Patterns

    Optional data types

  • The problem with null
  • How Optional improves upon null
  • How to use Optional in your code
  • Creating Optional objects
  • Default values and actions
  • Transforming Optionals with map
  • Chaining Optionals with flatMap
  • Rejecting values with filter

    Enhanced Concurrency with Lambdas

  • Introduction to Concurrency
  • Future and ExecutorService
  • CompletableFutures

    Day 3

    Asynchronous vs Synchronous Programming

  • Servlets
  • Asynchronous Servlets (3.0)
  • Why use asynchronous communications?
    • Performance
    • Testability
    • Fault Tolerance
  • Timeouts

    Approaches to Concurrency

  • The Reactive Manifesto and Functional Reactive Programming
  • Models of Concurrency
    • Event Based
    • Promises
    • The Actor Model
    • Reactive Streams

    Promises using Completable Futures

  • Motivation
  • Composition
  • Exception handling
  • Alternative Promise Implementations

    The Actor Model with Akka

  • What are Actors?
  • Using Akka
  • Testing actors
  • Alternative Actor Implementations

    Reactive Streams with RxJava

  • Introducing Reactive Streams
  • Pull vs. push models
  • Using RxJava
  • Java 9 Flow API
  • Alternative Reactive Stream Implementations

  • Audience


    If you are an experienced Java or OO developer, keen to learn to write more flexible and concise code using the latest Java language features and modern approaches like Reactive and Asynchronous programming, this Java course is for you!


    To get the most from this Modern Java course, you should have existing Java or OO programming experience in a commercial environment.

    Bring your own hardware

    You are required to bring your own laptop for this course, so you learn how to develop within your own environment. A full installation guide for the course software will be provided with your joining instructions.