Thinking Beyond Java 8

Course Curriculum

Chapter 1: Getting started

Lecture 1: Course Introduction

Lecture 2: A glimpse of what you will learn from the course

Lecture 3: Understanding the Time-Based JDK Releases

Lecture 4: Is Java still free ?

Lecture 5: More about the LTS Release

Lecture 6: Java 17 is here: LTS release update and a new license(free ?)

Lecture 7: Source Code: Downloading and how to navigate?

Chapter 2: Exploring Java 9

Lecture 1: Section Introduction

Lecture 2: Convenience Factory Methods for Collections: An Introduction

Lecture 3: Convenience Factory Methods for Collections: Understanding the characteristics

Lecture 4: Difference between the static factory of() and Collections.unmodifiableXXX()

Lecture 5: G1 Garbage Collector: An Introduction

Lecture 6: G1 Garbage Collector: An overview of how the G1 Garbage Collector works

Lecture 7: Compact Strings: The basics

Lecture 8: Compact Strings: Behind the scenes

Lecture 9: Indify String Concatenation: A peek into the bytecode

Lecture 10: Modularity: Why was it introduced?

Lecture 11: Modules: Understanding the basics

Lecture 12: Modules: Getting started with a modular application

Lecture 13: Modules: How to requires(s) another module?

Lecture 14: Modules: The unnamed module

Lecture 15: Modules: The automatic module

Lecture 16: Modules: Why do we need the automatic module?

Lecture 17: Modules: Quick summary of named, unnamed, and automatic modules

Lecture 18: Modules: Getting started with a multi-modular application, an example of two mod

Lecture 19: Modules: Advantages of the module system

Lecture 20: Understanding the Encapsulated Internal API's and jDeps

Lecture 21: jlink, The Java Linker: An Introduction

Lecture 22: jlink, The Java Linker: Using the tool with a single module

Lecture 23: jlink, The Java Linker: Using the tool with two modules

Lecture 24: JShell: An Introduction

Lecture 25: JShell: Exploring the commands

Lecture 26: Introduction to private methods in an interface

Lecture 27: A quick recap of the limit and skip methods introduced in JDK 8

Lecture 28: Stream API enhancement,takeWhile method: A prelude

Lecture 29: Stream API enhancement,takeWhile method: Understanding the basics

Lecture 30: Stream API enhancement,dropWhile method: Understanding the basics

Lecture 31: Stream API enhancement: Iterate using a Predicate

Lecture 32: Stream API enhancement: The ofNullable method

Lecture 33: Understanding the meaning of deprecation

Lecture 34: Deprecations and Removals

Lecture 35: Exercise

Chapter 3: Exploring Java 10

Lecture 1: Section Introduction

Lecture 2: Local-Variable Type Inference: An Introduction

Lecture 3: Local-Variable Type Inference: Java is still statically typed

Lecture 4: Local-Variable Type Inference: Where can it be used?

Lecture 5: Local-Variable Type Inference: Examples

Lecture 6: Local-Variable Type Inference: Some more examples

Lecture 7: Local-Variable Type Inference: Few more examples

Lecture 8: Local-Variable Type Inference: Final example

Lecture 9: Local-Variable Type Inference: Benefits and Summary

Lecture 10: A look at the orElseThrow method in the Optional class

Lecture 11: Using the copyOf method to create an unmodifiable list, set and map

Lecture 12: Application Class-Data Sharing: An Introduction

Lecture 13: Application Class-Data Sharing: Getting started with Class-Data sharing

Lecture 14: Application Class-Data Sharing: Getting started

Lecture 15: Application Class-Data Sharing: Benefits

Lecture 16: Improved Docker Container Detection in Java

Lecture 17: Exercise

Chapter 4: Exploring Java 11

Lecture 1: Section Introduction

Lecture 2: HTTP Client API: Introduction and motivation

Lecture 3: HTTP Client API: An overview of the important components

Lecture 4: HTTP Client API: Sending asynchronous requests

Lecture 5: HTTP Client API: Summary

Lecture 6: Local-Variable Syntax for Lambda Parameters: An Introduction

Lecture 7: String API: repeat method

Lecture 8: String API: isBlank method

Lecture 9: String API: strip method

Lecture 10: String API: Difference between strip and trim method

Lecture 11: String API: lines method

Lecture 12: Epsilon Garbage Collector: An Introduction

Lecture 13: Z Garbage Collector: An Introduction

Lecture 14: Deprecations and Removals: Java EE and Corba

Lecture 15: Deprecations and Removals: Applets and Nashorn

Lecture 16: Deprecations and Removals: JavaFX & OpenJFX

Lecture 17: Launching Single-File Source-Code Programs: Getting started

Lecture 18: Writing scripts using Java: Combining Shebang & Single-File Source-Code Programs

Lecture 19: File API: Introduction to the readString and writeString methods

Lecture 20: Predicate interface: Improving the readability of the code using the not( )

Lecture 21: JDK Flight Recorder: An Introduction

Lecture 22: JDK Mission Control: An Introduction

Lecture 23: JDK Mission Control: Exploring the User Interface

Lecture 24: JFR: Creating a recording & viewing the recording in Mission Control

Lecture 25: Exercise

Chapter 5: Exploring Java 12

Lecture 1: Section Introduction

Lecture 2: CompactNumberFormat: Formatting numbers in Compact form

Lecture 3: Teeing Collector: Composing two downstream collectors

Lecture 4: Files API: Determining equality between two files using the mismatch method

Lecture 5: Switch Expressions: A quick preview

Lecture 6: Shenandoah Garbage Collector: An Introduction

Lecture 7: String API: The indent method

Lecture 8: String API: The transform method

Lecture 9: Java Microbenchmark Harness(JMH): An Introduction

Lecture 10: Java Microbenchmark Harness(JMH): Getting started

Lecture 11: Java Microbenchmark Harness(JMH): How to benchmark?