Thinking Beyond Java 8

Thinking Beyond Java 8, available at $74.99, has an average rating of 4.25, with 162 lectures, based on 595 reviews, and has 4177 subscribers.

You will learn about Starting from Java 9, navigate through every release up to Java 17 Language Features Garbage Collectors like G1, ZGC, Epsilon, Shenandoah Super useful tools like Jpackage, JShell, JDK Flight Recorder, and more Performance-related improvements Removals and Deprecations Understand the new JDK release cycle and how the Java language and platform are evolving at a rapid pace Make well-informed decisions about moving beyond Java 8 Tips on Migration(Examples on JAXB, Hibernate, and Spring Boot) This course is ideal for individuals who are Java developers interested in getting up to speed with the ever-evolving Java language or You want to learn the new features of modern Java It is particularly useful for Java developers interested in getting up to speed with the ever-evolving Java language or You want to learn the new features of modern Java.

Enroll now: Thinking Beyond Java 8

Summary

Title: Thinking Beyond Java 8

Price: $74.99

Average Rating: 4.25

Number of Lectures: 162

Number of Published Lectures: 162

Number of Curriculum Items: 162

Number of Published Curriculum Objects: 162

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

Starting from Java 9, navigate through every release up to Java 17

Language Features

Garbage Collectors like G1, ZGC, Epsilon, Shenandoah

Super useful tools like Jpackage, JShell, JDK Flight Recorder, and more

Performance-related improvements

Removals and Deprecations

Understand the new JDK release cycle and how the Java language and platform are evolving at a rapid pace

Make well-informed decisions about moving beyond Java 8

Tips on Migration(Examples on JAXB, Hibernate, and Spring Boot)

Who Should Attend

Java developers interested in getting up to speed with the ever-evolving Java language

You want to learn the new features of modern Java

Target Audiences

Java developers interested in getting up to speed with the ever-evolving Java language

You want to learn the new features of modern Java

The Java platform is developing faster than at any time in its history. One key area of focus remains developer productivity.

The challenge is keeping up to date with all the latest changes.

This course will help you to-

1. Understand how the Java language and platform are evolving after Java 8

2. Be well-versed with different enhancements, innovations, improvements, and tools after Java 8

3. Know about the new JDK release cycle

4. Catch up with the latest modern features

Along with the above, broaden your horizon about different areas that one should look at in a given JDK release.

Starting from Java 9, we will incrementally move up to Java 17 and explore :

Language Features, Garbage Collectors, Library enhancements, Tools, Removals and Deprecations, and a lot more.

We target a single Java release in every section.

Some of the topics covered –

Text Blocks, Switch Expressions, Records, Pattern Matching for instanceof, Pattern Matching for switch, Sealed Classes

Garbage Collectors – G1, Epsilon, ZGC, Shenandoah

Modularity, jdeps, jlink, jdeprscan

Improved Docker Container Detection

Tool/Toolkit – Jpackage, JShell, JDK Flight Recorder

Factory methods in Collections

Compact Strings

Understand how String concatenation works behind the scenes

Some of the changes in the Stream API

Local Variable Type Inference along with recommendations on usage

Application Class Data Sharing

The new HTTP Client API

Handy String API changes

Writing scripts using the Java programming language

Teeing Collector

JMH (Java Microbenchmark Harness)

Encapsulated JDK internals

Tips on Migration (Examples on JAXB, Hibernate, and Spring Boot)

      and more!

The course will immensely benefit Java developers interested in getting up to speed with the ever-evolving Java language.

There are lots of exercises (along with the solution) that will help you to gain confidence.

The course is not a migration guide but we do cover numerous areas that can have an impact on migration.

What if you have questions?

I offer full support, 7 days a week, answering any questions you have.

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 APIs 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?

Instructors

Ajay Iyengar
Developer |Passionate teacher |Architect | Blogger

Rating Distribution

1 stars: 15 votes

2 stars: 11 votes

3 stars: 71 votes

4 stars: 234 votes

5 stars: 264 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!