The Java Workshop电子书

Preface

About the Book

About the Chapters

Conventions

Before You Begin

Installing the Code Bundle

1. Getting Started

Introduction

Writing, Compiling, and Executing Your Hello World Program

Exercise 1: Creating Your Hello World Program in Java

Basic Syntax and Naming Conventions

Printing Out Different Data Types

Variables and Variable Types

Exercise 2: Printing Different Types of Data

Primitive versus Reference Data Types

Null

Chars and Strings

Exercise 3: Declaring Strings

Doing Some Math

Exercise 4: Solving a Simple Trigonometry Problem

Comments Help You to Share Code

CLI versus GUI

Exercise 5: Running the Code from the CLI

Activity 1: Obtaining the Minimum of Two Numbers

Summary

2. Learning the Basics

Introduction

Controlling the Flow of Your Programs

Exercise 1: Creating a Basic if Statement

Comparison Operators

Exercise 2: Using Java Comparison Operators

Nested if Statements

Exercise 3: Implementing a Nested if Statement

Branching Two Ways with if and else

Exercise 4: Using if and else Statements

Using Complex Conditionals

Exercise 5: Using Logical Operators to Create Complex Conditionals

Using Arithmetic Operators in an if Condition

The Ternary Operator

Exercise 6: Using the Ternary Operator

Equality Can Be Tricky

Exercise 7: Comparing Decimal Values

Comparing Strings

Using switch Statements

Exercise 8: Using switch

Exercise 9: Allowing Cases to Fall Through

Using Java 12 Enhanced switch Statements

Exercise 10: Using Java 12 switch Statements

Looping and Performing Repetitive Tasks

Looping with the for Loop

Exercise 11: Using a Classic for Loop

Exercise 12: Using an Enhanced for Loop

Jumping Out of Loops with Break and Continue

Exercise 13: Using break and continue

Using the while Loop

Exercise 14: Using a while Loop

Using the do-while Loop

Handling Command-Line Arguments

Exercise 15: Testing Command-Line Arguments

Converting Command-Line Arguments

Exercise 16: Converting String to Integers and Doubles

Diving Deeper into Variables — Immutability

Comparing Final and Immutable

Using Static Values

Using Local Variable Type Inference

Activity 1: Taking Input and Comparing Ranges

Summary

3. Object-Oriented Programming

Introduction

The Anatomy of a Class

Working with Objects in Java

Checking the Precedence of a Class with instanceof

Exercise 1: Creating the WordTool Class

Activity 1: Adding the Frequency-of-Symbol Calculation to WordTool

Inheritance in Java

Overriding and Hiding Methods

Avoiding Overriding: Final Classes and Methods

Overloading Methods and Constructors

Recursion

Annotations

Interfaces

Inner Classes

Documenting with JavaDoc

Activity 2: Adding Documentation to WordTool

Summary

4. Collections, Lists and Java's Built-In APIs

Introduction

Arrays

Activity 1: Searching for Multiple Occurrences in an Array

Sets

Lists

Exercise 1: Creating the AnalyzeInput Application

Maps

Iterating through Collections

Exercise 2: Bringing Analytics into the AnalyzeInput Application

Sorting Collections

Exercise 3: Sort the Results from the AnalyzeInput Application

Properties

Activity 2: Iterating through Large Lists

Summary

5. Exceptions

Introduction

A Simple Exception Example

NullPointerException – Have No Fear

Catching Exceptions

Exercise 1: Logging Exceptions

Throws and Throw

Exercise 2: Breaking the Law (and Fixing It)

The finally Block

Activity 1: Designing an Exception Class Logging Data

Best Practices for Handling Exceptions

Where Do Exceptions Come from?

Summary

6. Libraries, Packages, and Modules

Introduction

Organizing Code into Packages

Importing Classes

Exercise 1: Importing Classes

Fully Qualified Class Names

Importing All Classes in a Package

Dealing with Duplicated Names

Static Imports

Creating a Package

Naming Your Package

Directories and Packages

Exercise 2: Creating a Package for a Fitness Tracking App

Building JAR Files

Exercise 3: Building a JAR File

Defining the Manifest

Exercise 4: Building an Executable JAR File

Build Tools

Maven

Exercise 5: Creating a Maven Project

Exercise 6: Adding Java Sources to the Maven Project

Exercise 7: Building the Maven Project

Exercise 8: Creating an Executable JAR with Maven

Using Gradle

Exercise 9: Creating a Gradle Project

Exercise 10: Building an Executable JAR with Gradle

Using Third-Party Libraries

Finding the Libraries

Adding a Project Dependency

Exercise 11: Adding a Third-Party Library Dependency

Using the Apache Commons Lang Library

Exercise 12: Using the Apache Commons Lang Library

Using Modules

Creating Modules

Exercise 13: Creating a Project for a Module

Exercise 14: Creating a Second Module Using the First One

Activity 1: Tracking Summer High Temperatures

Summary

7. Databases and JDBC

Introduction

Relational Databases

Relational Database Management Systems

Installing a Database

Exercise 1: Running the H2 Database

Introducing SQL

Exercise 2: Creating the customer Table

Inserting Data into a Table

Exercise 3: Inserting Data

Retrieving Data

Relating Tables

Exercise 4: Creating the email Table

Selecting Data from Multiple Tables

Modifying Existing Rows

Exercise 5: Modifying email Data

Deleting Data

JDBC—Accessing Databases from Java

Connecting to Databases

Querying Data with JDBC

Exercise 6: Querying Data with JDBC

Sanitizing User Input

Using Prepared Statements

Transactions and Rollback

Exercise 7: Using Prepared Statements with Transactions

Simplifying JDBC Programming

Using Object-Relational Mapping Software

Database Connection Pooling

Non-Relational, or NoSQL, Databases

Activity 1: Track Your Progress

Summary

8. Sockets, Files, and Streams

Introduction

Listing Files and Directories

Separating Directories from Files

Exercise 1: Listing the Contents of Subdirectories

Creating and Writing to a File

Activity 1: Writing the Directory Structure to a File

Reading an Existing File

Reading a Properties File

Exercise 2: Creating a Properties File from the CLI

What are Streams?

The Different Streams of the Java Language

What are Sockets?

Creating a SocketServer

Writing Data on and Reading Data from a Socket

Activity 2: Improving the EchoServer and EchoClient Programs

Blocking and Non-Blocking Calls

Summary

9. Working with HTTP

Introduction

Exploring HTTP

HTTP Request Methods

Representational State Transfer

Request Headers

Using HttpUrlConnection

Exercise 1: Creating a HEAD Request

Reading the Response Data with a GET Request

Exercise 2: Creating a GET Request

Dealing with Slow Connections

Requesting Parameters

Handling Redirects

Creating HTTP POST Requests

Exercise 3: Sending JSON Data with POST Requests

Parsing HTML Data

Exercise 4: Using jsoup to Extract Data from HTML

Delving into the java.net.http Module

Exercise 5: Getting HTML Contents Using the java.net.http Module

Activity 1: Using the jsoup Library to Download Files from the Web

Summary

10. Encryption

Introduction

Plaintext

Ciphertext

Ciphers

Keys

Symmetric Key Encryption

Exercise 1: Encrypting the String Using Advanced Encryption Standard

Block Ciphers

Initialization Vectors

Stream Ciphers

Asymmetric Key Encryption

Exercise 2: Encrypting the String Using the RSA Asymmetric Key Encryption

Encrypting Files

Exercise 3: Encrypting a File

Summary

11. Processes

Introduction

Launching a Process

Sending Input to a Child Process

Capturing the Output of a Child Process

Storing the Output of a Child Process in a File

Activity 1: Making a Parent Process to Launch a Child Process

Summary

12. Regular Expressions

Introduction

Decrypting Regular Expressions

Character Classes

Character Sets

Quantifiers

Anchors

Capturing Groups

Escaped Characters

Flags

Exercise 1: Implementing Regular Expressions

Activity 1: Regular Expressions to Check If the Entrance is Entered in the Desired Format

Regular Expressions in Java

Exercise 2: Extracting the Domain Using Pattern Matching

Exercise 3: Extracting Links Using Pattern Matching

Summary

13. Functional Programming with Lambda Expressions

Introduction

Background

Functional Programming

Side Effects

Deterministic Functions

Pure Functions

Exercise 1: Writing Pure Functions

Immutability of State

Exercise 2: Creating an Immutable Class

Activity 1: Modifying Immutable Lists

Immutable Collections

Exercise 3: Overriding the String Method

Functional Interfaces

Lambda Expressions

Exercise 4: Listing Spare Tires

Summary

14. Recursion

Introduction

Delving into Recursion

Exercise 1: Using Recursion to Overflow the Stack

Trying Tail Recursion

Exercise 2: Using Recursion to Calculate Factorials

Processing an XML Document

Exercise 3: Creating an XML File

Introducing the DOM XML API

Exercise 4: Traversing an XML Document

Activity 1: Calculating the Fibonacci Sequence

Summary

15. Processing Data with Streams

Introduction

Creating Streams

Parallel Streams

Encounter Order

Closing Streams

Terminal Operations

Intermediate Operations

Exercise 1: Using the Stream API

Activity 1: Applying Discount on the Items

Using Collectors

I/O Streams

Exercise 2: Converting CSV to a List

Activity 2: Searching for Specifics

Summary

16. Predicates and Other Functional Interfaces

Introduction

Predicate Interface

Exercise 1: Defining a predicate

Activity 1: Toggling the Sensor States

Consumer Interface

Exercise 2: Producing Side Effects

Function

Exercise 3: Extracting Data

Activity 2: Using a Recursive Function

Activity 3: Using a Lambda Function

Summary

17. Reactive Programming with Java Flow

Introduction

Publisher

SubmissionPublisher

Subscriber

Subscription

Exercise 1: A Simple Application with a Single Publisher and a Single Subscriber

Processor

Exercise 2: Using a Processor to Convert a Stream of Strings to Numbers

Activity 1: Let NumberProcessor Format Values as Integers

Summary

18. Unit Testing

Introduction

Getting Started with Unit Tests

Introducing JUnit

Writing Unit Tests with JUnit

Exercise 1: Writing a First Unit Test

Exercise 2: Writing a Successful Test

Deciding What to Test

Writing Parameterized Tests

Exercise 3: Writing a Parameterized Test

When Tests Won't Work—Disabling Tests

Test Setup

Exercise 4: Using Test Setup and Cleanup Methods

Mocking

Testing with Mocks Using Mockito

Exercise 5: Using Mocks when Testing

Activity 1: Counting the Words in the String

Summary

Appendix

1. Getting Started

Activity 1: Obtaining the Minimum of Two Numbers

2. Learning the Basics

Activity 1: Taking Input and Comparing Ranges

3. Object-Oriented Programming

Activity 1: Adding the Frequency-of-Symbol Calculation to WordTool

Activity 2: Adding Documentation to WordTool

4. Collections, List, and Java's Built-In APIs

Activity 1: Searching for Multiple Occurrences in an Array

Activity 2: Iterating through Large Lists

5. Exceptions

Activity 1: Designing an Exception Class Logging Data

6. Libraries, Packages, and Modules

Activity 1: Tracking Summer High Temperatures

7. Databases and JDBC

Activity 1: Track Your Progress

8. Sockets, Files, and Streams

Activity 1: Writing the Directory Structure to a File

Activity 2: Improving the EchoServer and EchoClient Programs

9. Working with HTTP

Activity 1: Using the jsoup Library to Download Files from the Web

11. Processes

Activity 1: Making a Parent Process to Launch a Child Process

12. Regular Expressions

Activity 1: Regular Expressions to Check If the Entrance is Entered in the Desired Format

13. Functional Programming with Lambda Expressions

Activity 1: Modifying Immutable Lists

14. Recursion

Activity 1: Calculating the Fibonacci Sequence

15. Processing Data with Streams

Activity 1: Applying Discount on the Items

Activity 2: Searching for Specifics

16. Predicates and Other Functional Interfaces

Activity 1: Toggling the Sensor States

Activity 2: Using a Recursive Function

Activity 3: Using a Lambda Function

17. Reactive Programming with Java Flow

Activity 1: Let NumberProcessor Format Values as Integers

18. Unit Testing

Activity 1: Counting the Words in the String