The Java Workshop: A New, Interactive Approach to Learning Java

Preface
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Chapter 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
Index