The Java Workshop

Spis treści książki

• Preface
  • About the Book
    • About the Chapters
    • Conventions
    • Before You Begin
      • Installation of JRE
      • Installation of JDK
      • Installation of IntelliJ IDEA
    • 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 Javas 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
    • JDBCAccessing 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 WorkDisabling 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
  • What Next?
    • The JavaScript Workshop
      • The Clojure Workshop
      • The Go Workshop
      • Please leave a review

pokaż cały spis treści

ukryj recenzje