More Java 17: An In-Depth Exploration of the Java Language and Its Features

Table of Contents
About the Authors
About the Technical Reviewers
Introduction
Chapter 1: Annotations
What Are Annotations?
Declaring an Annotation Type
Restrictions on Annotation Types
Restriction #1
Restriction #2
Restriction #3
Restriction #4
Restriction #5
Restriction #6
Default Value of an Annotation Element
Annotation Type and Its Instances
Using Annotations
Primitive Types
String Types
Class Types
Enum Type
Annotation Type
Array Type Annotation Element
No Null Value in an Annotation
Shorthand Annotation Syntax
Marker Annotation Types
Meta-Annotation Types
The Target Annotation Type
The Retention Annotation Type
The Inherited Annotation Type
The Documented Annotation Type
The Repeatable Annotation Type
Commonly Used Standard Annotations
Deprecating APIs
Suppressing Named Compile-Time Warnings
Overriding Methods
Declaring Functional Interfaces
Annotating Packages
Annotating Modules
Accessing Annotations at Runtime
Evolving Annotation Types
Annotation Processing at Source Code Level
Summary
Exercises
Chapter 2: Reflection
What Is Reflection?
Reflection in Java
Loading a Class
Using Class Literals
Using the Object::getClass() Method
Using the Class::forName() Method
Class Loaders
Reflecting on Classes
Reflecting on Fields
Reflecting on Executables
Reflecting on Methods
Reflecting on Constructors
Creating Objects
Invoking Methods
Accessing Fields
Deep Reflection
Deep Reflection Within a Module
Deep Reflection Across Modules
Deep Reflection and Unnamed Modules
Deep Reflection on JDK Modules
Reflecting on Arrays
Expanding an Array
Who Should Use Reflection?
Summary
Exercises
Chapter 3: Generics
What Are Generics?
Supertype-Subtype Relationship
Raw Types
Unbounded Wildcards
Upper-Bounded Wildcards
Lower-Bounded Wildcards
Generic Methods and Constructors
Type Inference in Generic Object Creation
No Generic Exception Classes
No Generic Anonymous Classes
Generics and Arrays
Runtime Class Type of Generic Objects
Heap Pollution
Varargs Methods and Heap Pollution Warnings
Summary
Exercises
Chapter 4: Lambda Expressions
What Is a Lambda Expression?
Why Do We Need Lambda Expressions?
Syntax for Lambda Expressions
Omitting Parameter Types
Using Local Variable Syntax for Parameters
Declaring a Single Parameter
Declaring No Parameters
Parameters with Modifiers
Declaring the Body of Lambda Expressions
Target Typing
Functional Interfaces
Using the @FunctionalInterface Annotation
Generic Functional Interface
Intersection Type and Lambda Expressions
Commonly Used Functional Interfaces
Using the Function Interface
Using the Predicate Interface
Using Functional Interfaces
Method References
Static Method References
Instance Method References
Supertype Instance Method References
Constructor References
Generic Method References
Lexical Scoping
Variable Capture
Jumps and Exits
Recursive Lambda Expressions
Comparing Objects
Summary
Exercises
Chapter 5: Threads
What Is a Thread?
Creating Threads in Java
Specifying Your Code for a Thread
Inheriting Your Class from the Thread Class
Implementing the Runnable Interface
Using a Method Reference
A Quick Example
Using Multiple Threads in a Program
Issues in Using Multiple Threads
Java Memory Model
Atomicity
Visibility
Ordering
Object’s Monitor and Thread Synchronization
Rule #1
Rule #2
The Producer/Consumer Synchronization Problem
Which Thread Is Executing?
Letting a Thread Sleep
I Will Join You in Heaven
Be Considerate to Others and Yield
Lifecycle of a Thread
Priority of a Thread
Is It a Demon or a Daemon?
Am I Interrupted?
Threads Work in a Group
Volatile Variables
Stopping, Suspending, and Resuming Threads
Spin-Wait Hints
Handling an Uncaught Exception in a Thread
Thread Concurrency Packages
Atomic Variables
CAS
Scalar Atomic Variable Classes
Atomic Array Classes
Atomic Field Updater Classes
Atomic Compound Variable Classes
Explicit Locks
Synchronizers
Semaphores
Barriers
Phasers
Latches
Exchangers
The Executor Framework
Result-Bearing Tasks
Scheduling a Task
Handling Uncaught Exceptions in a Task Execution
Executor’s Completion Service
The Fork/Join Framework
Steps in Using the Fork/Join Framework
Step 1: Declaring a Class to Represent a Task
Step 2: Implementing the compute() Method
Step 3: Creating a Fork/Join Thread Pool
Step 4: Creating the Fork/Join Task
Step 5: Submitting the Task to the Fork/Join Pool for Execution
A Fork/Join Example
Thread-Local Variables
Setting Stack Size of a Thread
Summary
Exercises
Chapter 6: Streams
What Are Streams?
Streams Have No Storage
Infinite Streams
Internal Iteration vs. External Iteration
Imperative vs. Functional
Stream Operations
Ordered Streams
Streams Are Not Reusable
Architecture of the Streams API
A Quick Example
Creating Streams
Streams from Values
Empty Streams
Streams from Functions
Streams from Arrays
Streams from Collections
Streams from Files
Streams from Other Sources
Representing an Optional Value
Applying Operations to Streams
Debugging a Stream Pipeline
Applying the ForEach Operation
Applying the Map Operation
Flattening Streams
Applying the Filter Operation
Applying the Reduce Operation
Collecting Data Using Collectors
Collecting Summary Statistics
Collecting Data in Maps
Joining Strings Using Collectors
Grouping Data
Partitioning Data
Adapting the Collector Results
Finding and Matching in Streams
Parallel Streams
Summary
Exercises
Chapter 7: Implementing Services
What Is a Service?
Discovering Services
Providing Service Implementations
Defining the Service Interface
Obtaining Service Provider Instances
Defining the Service
Defining Service Providers
Defining a Default Prime Service Provider
Defining a Faster Prime Service Provider
Defining a Probable Prime Service Provider
Testing the Prime Service
Testing Prime Service in Legacy Mode
Summary
Exercises
Chapter 8: Network Programming
What Is Network Programming?
Network Protocol Suite
IP Addressing Scheme
IPv4 Addressing Scheme
IPv6 Addressing Scheme
Special IP Addresses
Loopback IP Address
Unicast IP Address
Multicast IP Address
Anycast IP Address
Broadcast IP Address
Unspecified IP Address
Port Numbers
Socket API and Client-Server Paradigm
The Socket Primitive
The Bind Primitive
The Listen Primitive
The Accept Primitive
The Connect Primitive
The Send/Sendto Primitive
The Receive/ReceiveFrom Primitive
The Close Primitive
Representing a Machine Address
Representing a Socket Address
Creating a TCP Server Socket
Creating a TCP Client Socket
Putting a TCP Server and Clients Together
Working with UDP Sockets
Creating a UDP Echo Server
A Connected UDP Socket
UDP Multicast Sockets
URI, URL, and URN
URI and URL As Java Objects
Accessing the Contents of a URL
Non-blocking Socket Programming
Socket Security Permissions
Asynchronous Socket Channels
Setting Up an Asynchronous Server Socket Channel
Setting Up an Asynchronous Client Socket Channel
Putting the Server and the Client Together
Datagram-Oriented Socket Channels
Creating the Datagram Channel
Setting the Channel Options
Sending Datagrams
Multicasting Using Datagram Channels
Creating the Datagram Channel
Setting the Channel Options
Binding the Channel
Setting the Multicast Network Interface
Joining the Multicast Group
Receiving a Message
Closing the Channel
Further Reading
Summary
Exercises
Chapter 9: Java Remote Method Invocation
What Is Java Remote Method Invocation?
The RMI Architecture
Developing an RMI Application
Writing the Remote Interface
Implementing the Remote Interface
Writing the RMI Server Program
Writing the RMI Client Program
Separating the Server and Client Code
Running the RMI Application
Running the RMI Registry
Running the RMI Server
Running an RMI Client Program
Troubleshooting an RMI Application
java.rmi.server.ExportException
java.security.AccessControlException
java.lang.ClassNotFoundException
Debugging an RMI Application
Dynamic Class Downloading
Garbage Collection of Remote Objects
Summary
Exercises
Chapter 10: Scripting in Java
What Is Scripting in Java?
Installing Script Engines in Maven
Executing Your First Script
Using Other Scripting Languages
Exploring the javax.script Package
The ScriptEngine and ScriptEngineFactory Interfaces
The AbstractScriptEngine Class
The ScriptEngineManager Class
The Compilable Interface and the CompiledScript Class
The Invocable Interface
The Bindings Interface and the SimpleBindings Class
The ScriptContext Interface and the SimpleScriptContext Class
The ScriptException Class
Discovering and Instantiating Script Engines
Executing Scripts
Passing Parameters
Passing Parameters from Java Code to Scripts
Passing Parameters from Scripts to Java Code
Advanced Parameter Passing Techniques
Bindings
Scope
Defining the Script Context
Putting Them Together
Using a Custom ScriptContext
Return Value of the eval( ) Method
Reserved Keys for Engine Scope Bindings
Changing the Default ScriptContext
Sending Script Output to a File
Invoking Procedures in Scripts
Implementing Java Interfaces in Scripts
Using Compiled Scripts
Using Java in Scripting Languages
Declaring Variables
Importing Java Classes
Implementing a Script Engine
The Expression Class
The JKScriptEngine Class
The JKScriptEngineFactory Class
Packaging the JKScript Files
Using the JKScript Script Engine
JavaFX in Groovy
Summary
Exercises
Chapter 11: Process API
What Is the Process API?
Knowing the Runtime Environment
The Current Process
Querying the Process State
Comparing Processes
Creating a Process
Obtaining a Process Handle
Terminating Processes
Managing Process Permissions
Summary
Exercises
Chapter 12: Packaging Modules
The JAR Format
What Is a Multi-release JAR?
Creating Multi-release JARs
Rules for Multi-release JARs
Multi-release JARs and JAR URL
Multi-release Manifest Attribute
The JMOD Format
Using the jmod Tool
Summary
Exercises
Chapter 13: Custom Runtime Images
What Is a Custom Runtime Image?
Creating Custom Runtime Images
Binding Services
Using Plugins with the jlink Tool
The jimage Tool
Summary
Exercises
Chapter 14: Miscellanea
Deleted Chapters from Previous Editions
More JDK17 Novelties
Local Variables with Automatic Types
Launch Single-File Source Code Programs
Enhanced switch Statements
Text Blocks
Enhanced instanceof Operator
Value Classes: Records
Sealed Classes
Summary
Appendix: Solutions to the Exercises
Exercises in Chapter 1
Exercises in Chapter 2
Exercises in Chapter 3
Exercises in Chapter 4
Exercises in Chapter 5
Exercises in Chapter 6
Exercises in Chapter 7
Exercises in Chapter 8
Exercises in Chapter 9
Exercises in Chapter 10
Exercises in Chapter 11
Exercises in Chapter 12
Exercises in Chapter 13
Index