Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Java 11 Cookbook

By : Nick Samoylov, Sanaulla

1 (1)

Java 11 Cookbook

1 (1)

By: Nick Samoylov, Sanaulla

Overview of this book

For more than three decades, Java has been on the forefront of developing robust software that has helped versatile businesses meet their requirements. Being one of the most widely used programming languages in history, it’s imperative for Java developers to discover effective ways of using it in order to take full advantage of the power of the latest Java features. Java 11 Cookbook offers a range of software development solutions with simple and straightforward Java 11 code examples to help you build a modern software system. Starting with the installation of Java, each recipe addresses various problem by explaining the solution and offering insights into how it works. You’ll explore the new features added to Java 11 that will make your application modular, secure, and fast. The book contains recipes on functional programming, GUI programming, concurrent programming, and database programming in Java. You’ll also be taken through the new features introduced in JDK 18.3 and 18.9. By the end of this book, you’ll be equipped with the skills required to write robust, scalable, and optimal Java code effectively.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Sections

Get in touch

Free Chapter

Installation and a Sneak Peek into Java 11

Installation and a Sneak Peek into Java 11

Introduction

Installing JDK 18.9 on Windows and setting up the PATH variable

Installing JDK 18.9 on Linux (Ubuntu, x64) and configuring the PATH variable

Compiling and running a Java application

What's new in Java 11?

Using application class-data sharing

Fast Track to OOP - Classes and Interfaces

Fast Track to OOP - Classes and Interfaces

Introduction

Implementing object-oriented design (OOD)

Using inner classes

Using inheritance and aggregation

Coding to an interface

Creating interfaces with default and static methods

Creating interfaces with private methods

A better way to work with nulls using Optional

Using the utility class Objects

Modular Programming

Modular Programming

Introduction

Using jdeps to find dependencies in a Java application

Creating a simple modular application

Creating a modular JAR

Using a module JAR with pre-Project Jigsaw JDK applications

Bottom-up migration

Top-down migration

Using services to create loose coupling between the consumer and provider modules

Creating a custom modular runtime image using jlink

Compiling for older platform versions

Creating multi-release JARs

Using Maven to develop a modular application

Making your library module-path-friendly

How to open a module for reflection

Going Functional

Going Functional

Introduction

Using standard functional interfaces

Creating a functional interface

Understanding lambda expressions

Using lambda expressions

Using method references

Leveraging lambda expressions in your programs

Streams and Pipelines

Streams and Pipelines

Introduction

Creating immutable collections using the of() and copyOf() factory methods

Creating and operating on streams

Using numeric streams for arithmetic operations

Completing streams by producing collections

Completing streams by producing maps

Completing streams by producing maps using grouping collectors

Creating stream operation pipeline

Processing streams in parallel

Database Programming

Database Programming

Introduction

Connecting to a database using JDBC

Setting up the tables required for DB interactions

Performing CRUD operations using JDBC

Using the Hikari Connection Pool (HikariCP)

Using prepared statements

Using transactions

Working with large objects

Executing stored procedures

Using batch operations for a large set of data

Using MyBatis for CRUD operations

Using the Java Persistence API and Hibernate

Concurrent and Multithreaded Programming

Concurrent and Multithreaded Programming

Introduction

Using the basic element of concurrency – thread

Different synchronization approaches

Immutability as a means of achieving concurrency

Using concurrent collections

Using the executor service to execute async tasks

Using fork/join to implement divide-and-conquer

Using flow to implement the publish-subscribe pattern

Better Management of the OS Process

Better Management of the OS Process

Introduction

Spawning a new process

Redirecting the process output and error streams to file

Changing the working directory of a subprocess

Setting the environment variable for a subprocess

Running shell scripts

Obtaining the process information of the current JVM

Obtaining the process information of the spawned process

Managing the spawned process

Enumerating live processes in the system

Connecting multiple processes using pipe

Managing subprocesses

RESTful Web Services Using Spring Boot

RESTful Web Services Using Spring Boot

Introduction

Creating a simple Spring Boot application

Interacting with the database

Creating a RESTful web service

Creating multiple profiles for Spring Boot

Deploying RESTful web services to Heroku

Containerizing the RESTful web service using Docker

Monitoring the Spring Boot 2 application using Micrometer and Prometheus

Networking

Networking

Introduction

Making an HTTP GET request

Making an HTTP POST request

Making an HTTP request for a protected resource

Making an asynchronous HTTP request

Making an HTTP request using Apache HttpClient

Making an HTTP request using the Unirest HTTP client library

Memory Management and Debugging

Memory Management and Debugging

Introduction

Understanding the G1 garbage collector

Unified logging for JVM

Using the jcmd command for the JVM

Try-with-resources for better resource handling

Stack walking for improved debugging

Using the memory-aware coding style

Best practices for better memory usage

Understanding Epsilon, a low-overhead garbage collector

The Read-Evaluate-Print Loop (REPL) Using JShell

The Read-Evaluate-Print Loop (REPL) Using JShell

Introduction

Getting familiar with REPL

Navigating JShell and its commands

Evaluating code snippets

Object-oriented programming in JShell

Saving and restoring the JShell command history

Using the JShell Java API

Working with New Date and Time APIs

Working with New Date and Time APIs

Introduction

How to work with time zone-independent date and time instances

How to construct time zone-dependent time instances

How to create a date-based period between date instances

How to create a time-based period between time instances

How to represent epoch time

How to manipulate date and time instances

How to compare date and time

How to work with different calendar systems

How to format dates using the DateTimeFormatter

Testing

Testing

Introduction

Behavioral testing using Cucumber

Unit testing of an API using JUnit

Unit testing by mocking dependencies

Using fixtures to populate data for testing

Integration testing

The New Way of Coding with Java 10 and Java 11

The New Way of Coding with Java 10 and Java 11

Introduction

Using local-variable type inference

Using local-variable syntax for lambda parameters

GUI Programming Using JavaFX

GUI Programming Using JavaFX

Introduction

Creating a GUI using JavaFX controls

Using the FXML markup to create a GUI

Using CSS to the style elements in JavaFX

Creating a bar chart

Creating a pie chart

Embedding HTML in an application

Embedding media in an application

Adding effects to controls

Using the Robot API

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

1 (1)

5 star

0

4 star

0

3 star

0

2 star

0

1 star

100%

Coding to an interface

In this recipe, you will learn the last of the OOP concepts, called interface, and further practice the usage of aggregation and polymorphism as well as inner classes and inheritance.

Getting ready

An interface defines the signatures of the methods one can expect to see in the class that implements the interface. It is the public face of the functionality that's accessible to a client and is thus often called an Application Program Interface (API). It supports polymorphism and aggregation, and facilitates a more flexible and extensible design.

An interface is implicitly abstract, which means it cannot be instantiated. No object can be created based on an interface only, without implementing it...

Search

Your notes and bookmarks