On Java 8

Table of Contents
Copyright
Foreword to the Leanpub Edition
	Updates
	January 2021 Update
	March 2021 Update
Preface
	Goals
	Language Design Errors
	Tested Examples
	Popularity
	Android Programmers
	This is Only an eBook
	Colophon
	Thanks
	Dedication
Introduction
	Prerequisites
	JDK HTML Documentation
	Thinking in C
	Source Code
	Coding Standards
	Bug Reports
	What About User Interfaces?
What is an Object?
	The Progress of Abstraction
	An Object Has an Interface
	Objects Provide Services
	The Hidden Implementation
	Reusing the Implementation
	Inheritance
	Interchangeable Objects with Polymorphism
	The Singly-Rooted Hierarchy
	Collections
	Object Creation & Lifetime
	Exception Handling: Dealing with Errors
	Summary
Installing Java and the Book Examples
	Editors
	The Shell
	Installing Java
	Verify Your Installation
	Installing and Running the Book Examples
Objects Everywhere
	You Manipulate Objects with References
	You Must Create All the Objects
	Comments
	You Never Need to Destroy an Object
	Creating New Data Types: class
	Methods, Arguments, and Return Values
	Writing a Java Program
	Your First Java Program
	Coding Style
	Summary
Operators
	Using Java Operators
	Precedence
	Assignment
	Mathematical Operators
	Auto Increment and Decrement
	Relational Operators
	Logical Operators
	Literals
	Bitwise Operators
	Shift Operators
	Ternary if-else Operator
	String Operator + and +=
	Common Pitfalls When Using Operators
	Casting Operators
	Java Has No ``sizeof\'\'
	A Compendium of Operators
	Summary
Control Flow
	true and false
	if-else
	Iteration Statements
	For-in Syntax
	return
	break and continue
	The Infamous ``Goto\'\'
	switch
	Switching on Strings
	Summary
Housekeeping
	Guaranteed Initialization with the Constructor
	Method Overloading
	Zero-Argument Constructors
	The this Keyword
	Cleanup: Finalization and Garbage Collection
	Member Initialization
	Constructor Initialization
	Array Initialization
	Enumerated Types
	Summary
Implementation Hiding
	package: the Library Unit
	Java Access Specifiers
	Interface and Implementation
	Class Access
	Summary
Reuse
	Composition Syntax
	Inheritance Syntax
	Delegation
	Combining Composition and Inheritance
	Choosing Composition vs. Inheritance
	protected
	Upcasting
	The final Keyword
	Initialization and Class Loading
	Summary
Polymorphism
	Upcasting Revisited
	The Twist
	Constructors and Polymorphism
	Covariant Return Types
	Designing with Inheritance
	Summary
Interfaces
	Abstract Classes and Methods
	Defining Interfaces
	Abstract Classes vs. Interfaces
	Complete Decoupling
	Combining Multiple Interfaces
	Extending an Interface with Inheritance
	Adapting to an Interface
	Fields in Interfaces
	Nesting Interfaces
	Interfaces and Factories
	Summary
Inner Classes
	Creating Inner Classes
	The Link to the Outer Class
	Using .this and .new
	Inner Classes and Upcasting
	Inner Classes in Methods and Scopes
	Anonymous Inner Classes
	Nested Classes
	Why Inner Classes?
	Inheriting from Inner Classes
	Can Inner Classes Be Overridden?
	Local Inner Classes
	Inner-Class Identifiers
	Summary
Collections
	Generics and Type-Safe Collections
	Basic Concepts
	Adding Groups of Elements
	Printing Collections
	List
	Iterators
	LinkedList
	Stack
	Set
	Map
	Queue
	Collection vs. Iterator
	for-in and Iterators
	Summary
Functional Programming
	Old vs. New
	Lambda Expressions
	Method References
	Functional Interfaces
	Higher-Order Functions
	Closures
	Function Composition
	Currying and Partial Evaluation
	Pure Functional Programming
	Summary
Streams
	Java 8 Stream Support
	Stream Creation
	Intermediate Operations
	Optional
	Terminal Operations
	Summary
Exceptions
	Concepts
	Basic Exceptions
	Catching an Exception
	Creating Your Own Exceptions
	The Exception Specification
	Catching Any Exception
	Standard Java Exceptions
	Performing Cleanup with finally
	Exception Restrictions
	Constructors
	Try-With-Resources
	Exception Matching
	Alternative Approaches
	Exception Guidelines
	Summary
Validating Your Code
	Testing
	Preconditions
	Test-Driven Development
	Logging
	Debugging
	Benchmarking
	Profiling and Optimizing
	Style Checking
	Static Error Analysis
	Code Reviews
	Pair Programming
	Refactoring
	Continuous Integration
	Summary
Files
	File and Directory Paths
	Directories
	File Systems
	Watching a Path
	Finding Files
	Reading & Writing Files
	Summary
Strings
	Immutable Strings
	Overloading + vs. StringBuilder
	Unintended Recursion
	Operations on Strings
	Formatting Output
	Regular Expressions
	Scanning Input
	StringTokenizer
	Summary
Reflection
	The Need for Reflection
	The Class Object
	Checking Before a Cast
	Registered Factories
	Instanceof vs. Class Equivalence
	Runtime Class Information
	Dynamic Proxies
	Using Optional
	Interfaces and Type Information
	Summary
Generics
	Comparison with C++
	Simple Generics
	Generic Interfaces
	Generic Methods
	Building Complex Models
	The Mystery of Erasure
	Compensating for Erasure
	Bounds
	Wildcards
	Issues
	Self-Bounded Types
	Dynamic Type Safety
	Exceptions
	Mixins
	Latent Typing
	Compensating for the Lack of (Direct) Latent Typing
	Assisted Latent Typing in Java 8
	Summary: Is Casting Really So Bad?
Arrays
	Why Arrays are Special
	Arrays are First-Class Objects
	Returning an Array
	Multidimensional Arrays
	Arrays and Generics
	Arrays.fill()
	Arrays.setAll()
	Incremental Generators
	Random Generators
	Generics and Primitive Arrays
	Modifying Existing Array Elements
	An Aside On Parallelism
	Arrays Utilities
	Copying an Array
	Comparing Arrays
	Streams and Arrays
	Sorting Arrays
	Searching with Arrays.binarySearch()
	Accumulating with parallelPrefix()
	Summary
Enumerations
	Basic enum Features
	Adding Methods to an enum
	enums in switch Statements
	The Mystery of values()
	Implements, not Inherits
	Random Selection
	Using Interfaces for Organization
	Using EnumSet Instead of Flags
	Using EnumMap
	Constant-Specific Methods
	Multiple Dispatching
	Summary
Annotations
	Basic Syntax
	Writing Annotation Processors
	Using javac to Process Annotations
	Annotation-Based Unit Testing
	Summary
Concurrent Programming
	The Terminology Problem
	Concurrency Superpowers
	Concurrency is for Speed
	The Four Maxims of Java Concurrency
	The Brutal Truth
	The Rest of the Chapter
	Parallel Streams
	Creating and Running Tasks
	Terminating Long-Running Tasks
	CompletableFutures
	Deadlock
	Constructors are not Thread-Safe
	Effort, Complexity, Cost
	Summary
Patterns
	The Pattern Concept
	Singleton
	Classifying Patterns
	Template Method
	Fronting for an Implementation
	Factories: Encapsulating Object Creation
	Function Objects
	Changing the Interface
	Interpreter: Run-Time Flexibility
	Callbacks
	Multiple Dispatching
	Pattern Refactoring
	Summary
Appendix: Supplements
	On Java 8 Example Code
	Thinking in C: Foundations for Java
	Hands-On Java eSeminar
Appendix: Programming Guidelines
	Design
	Implementation
Appendix: Javadoc
	Syntax
	Embedded HTML
	Some Example Tags
	Documentation Example
Appendix: Passing and Returning Objects
	Passing References
	Making Local Copies
	Controlling Cloneability
	Immutable Classes
	Summary
Appendix: I/O Streams
	Types of InputStream
	Types of OutputStream
	Adding Attributes and Useful Interfaces
	Readers & Writers
	Off By Itself: RandomAccessFile
	Typical Uses of I/O Streams
	Summary
Appendix: Standard I/O
	Reading from Standard Input
	Changing System.out to a PrintWriter
	Redirecting Standard I/O
	Process Control
Appendix: New I/O
	ByteBuffers
	Converting Data
	Fetching Primitives
	View Buffers
	Data Manipulation with Buffers
	Memory-Mapped Files
	File Locking
Appendix: Understanding equals() and hashCode()
	A Canonical equals()
	Hashing and Hash Codes
	Tuning a HashMap
Appendix: Collection Topics
	Sample Data
	List Behavior
	Set Behavior
	Using Functional Operations with any Map
	Selecting Parts of a Map
	Filling Collections
	Custom Collection and Map using Flyweight
	Collection Functionality
	Optional Operations
	Sets and Storage Order
	Queues
	Understanding Maps
	Utilities
	Holding References
	Java 1.0/1.1 Collections
	Summary
Appendix: Low-Level Concurrency
	What is a Thread?
	Catching Exceptions
	Sharing Resources
	The volatile Keyword
	Atomicity
	Critical Sections
	Library Components
	Summary
Appendix: Data Compression
	Simple Compression with GZIP
	Multifile Storage with Zip
	Java Archives (Jars)
Appendix: Object Serialization
	Finding the Class
	Controlling Serialization
	Using Persistence
Appendix: Benefits and Costs of Static Type Checking
	Foreword to the 2021 Edition
	Foreword to the Original Edition
	Static Type Checking vs. Testing
	How to Argue about Typing
	The Cost of Productivity
	Static vs. Dynamic
Appendix: The Positive Legacy of C++ and Java
Appendix: Becoming a Programmer
	How I Got Started in Programming
	A Career in Computing
	The Mythical 5%
	Writing Software Is Like … Writing
	Programming as Typing
	Do What You Love