Eckel Bruce - On Java 8 [2021, PDF/EPUB/MOBI, ENG] + code torrent

Книги и журналы » Компьютерная литература » Программирование (книги)

On Java 8

Год издания: 2021
Автор: Eckel Bruce

Издательство: Leanpub; MindView LLC
ISBN: 978-0-9818725-2-0
Язык: Английский

Формат: PDF/ePub/MOBI
Качество: Издательский макет или текст (eBook)
Интерактивное оглавление: Да
Количество страниц: 1778

Описание: By the author of "Thinking in Java," covering version 8 of the Java programming language. This book is intended for “dedicated beginners.” It doesn’t assume you know anything about programming and takes you through the material step-by-step. However, I assume you are able to figure things out. It’s not a “dummies” or “idiot’s” guide.
[spoiler="Примеры страниц"]

[/spoiler]
[spoiler="Оглавление"]
Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Language Design Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Tested Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Popularity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Android Programmers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
This is Only an eBook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Colophon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Thanks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Dedication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Prerequisites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
JDK HTML Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Thinking in C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Source Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Coding Standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Bug Reports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
What About User Interfaces? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

What is an Object? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
The Progress of Abstraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
An Object Has an Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Objects Provide Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
The Hidden Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Reusing the Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Interchangeable Objects with Polymorphism . . . . . . . . . . . . . . . . . . 33
The Singly-Rooted Hierarchy . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Object Creation & Lifetime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Exception Handling: Dealing with Errors . . . . . . . . . . . . . . . . . . . . 42
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

Installing Java and the Book Examples . . . . . . . . . . . . . . . . . . . . . . . 45
Editors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
The Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Installing Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Verify Your Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Installing and Running the Book Examples . . . . . . . . . . . . . . . . . . . 50
Objects Everywhere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
You Manipulate Objects with References . . . . . . . . . . . . . . . . . . . . 52
You Must Create All the Objects . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
You Never Need to Destroy an Object . . . . . . . . . . . . . . . . . . . . . . 59
Creating New Data Types: class . . . . . . . . . . . . . . . . . . . . . . . . . 61
Methods, Arguments, and Return Values . . . . . . . . . . . . . . . . . . . . 63
Writing a Java Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Your First Java Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Coding Style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Using Java Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Precedence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Mathematical Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Auto Increment and Decrement . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Relational Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Logical Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Bitwise Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Shift Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Ternary if-else Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
String Operator + and += . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Common Pitfalls When Using Operators . . . . . . . . . . . . . . . . . . . . 106
Casting Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Java Has No “sizeof” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
A Compendium of Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

Control Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
true and false . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
if-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Iteration Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
For-in Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
break and continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
The Infamous “Goto” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Switching on Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

Housekeeping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Guaranteed Initialization with the Constructor . . . . . . . . . . . . . . . . . 147
Method Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Zero-Argument Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
The this Keyword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Cleanup: Finalization and Garbage Collection . . . . . . . . . . . . . . . . . 165
Member Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Constructor Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Array Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Enumerated Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

Implementation Hiding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
package: the Library Unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Java Access Specifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Interface and Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Class Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226

Reuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Composition Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Inheritance Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
Delegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Combining Composition and Inheritance . . . . . . . . . . . . . . . . . . . . 239
Choosing Composition vs. Inheritance . . . . . . . . . . . . . . . . . . . . . . 247
protected . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Upcasting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
The final Keyword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
Initialization and Class Loading . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Upcasting Revisited . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
The Twist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Constructors and Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . 284
Covariant Return Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Designing with Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
Abstract Classes and Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
Defining Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Abstract Classes vs. Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
Complete Decoupling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Combining Multiple Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Extending an Interface with Inheritance . . . . . . . . . . . . . . . . . . . . . 333
Adapting to an Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
Fields in Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
Nesting Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Interfaces and Factories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

Inner Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Creating Inner Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
The Link to the Outer Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Using .this and .new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
Inner Classes and Upcasting . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
Inner Classes in Methods and Scopes . . . . . . . . . . . . . . . . . . . . . . . 359
Anonymous Inner Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
Nested Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Why Inner Classes? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
Inheriting from Inner Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
Can Inner Classes Be Overridden? . . . . . . . . . . . . . . . . . . . . . . . . 386
Local Inner Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Inner-Class Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391

Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Generics and Type-Safe Collections . . . . . . . . . . . . . . . . . . . . . . . . 394
Basic Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
Adding Groups of Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
Printing Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
LinkedList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
Collection vs. Iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
for-in and Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445

Functional Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
Old vs. New . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
Lambda Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Method References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
Functional Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
Higher-Order Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
Closures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
Function Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Currying and Partial Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . 489
Pure Functional Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492

Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
Java 8 Stream Support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
Stream Creation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
Intermediate Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
Optional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
Terminal Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551

Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
Basic Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
Catching an Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556
Creating Your Own Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . 558
The Exception Specification . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
Catching Any Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
Standard Java Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
Performing Cleanup with finally . . . . . . . . . . . . . . . . . . . . . . . . 583
Exception Restrictions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
Try-With-Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601
Exception Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
Alternative Approaches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
Exception Guidelines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621

Validating Your Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
Preconditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
Test-Driven Development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
Logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665
Benchmarking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670
Profiling and Optimizing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681
Style Checking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682
Static Error Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
Code Reviews . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
Pair Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684
Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
Continuous Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 686
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 688

Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 690
File and Directory Paths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 690
Directories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699
File Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703
Watching a Path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705
Finding Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708
Reading & Writing Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 714

Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715
Immutable Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715
Overloading + vs. StringBuilder . . . . . . . . . . . . . . . . . . . . . . . . 716
Unintended Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 722
Operations on Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
Formatting Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728
Regular Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 738
Scanning Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 763
StringTokenizer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 768
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 769

Reflection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 770
The Need for Reflection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 770
The Class Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 773
Checking Before a Cast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787
Registered Factories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801
Instanceof vs. Class Equivalence . . . . . . . . . . . . . . . . . . . . . . . 804
Runtime Class Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 806
Dynamic Proxies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 811
Using Optional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 816
Interfaces and Type Information . . . . . . . . . . . . . . . . . . . . . . . . . . 827
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835

Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
Comparison with C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838
Simple Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 839
Generic Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 849
Generic Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853
Building Complex Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 866
The Mystery of Erasure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 869
Compensating for Erasure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 882
Bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 895
Wildcards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 900
Issues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 922
Self-Bounded Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 931
Dynamic Type Safety . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 940
Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 942
Mixins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 944
Latent Typing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 952
Compensating for the Lack of (Direct) Latent Typing . . . . . . . . . . . . . 960
Assisted Latent Typing in Java 8 . . . . . . . . . . . . . . . . . . . . . . . . . . 967
Summary: Is Casting Really So Bad? . . . . . . . . . . . . . . . . . . . . . . . 973

Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 976
Why Arrays are Special . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 976
Arrays are First-Class Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . 981
Returning an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 984
Multidimensional Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 986
Arrays and Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 991
Arrays.fill() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 994
Arrays.setAll() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 996
Incremental Generators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 998
Random Generators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1008
Generics and Primitive Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . 1019
Modifying Existing Array Elements . . . . . . . . . . . . . . . . . . . . . . . 1024
An Aside On Parallelism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1024
Arrays Utilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1027
Copying an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1028
Comparing Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031
Streams and Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1033
Sorting Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1035
Searching with Arrays.binarySearch() . . . . . . . . . . . . . . . . . . . 1041
Accumulating with parallelPrefix() . . . . . . . . . . . . . . . . . . . . . 1044
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1046

Enumerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1050
Basic enum Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1050
Adding Methods to an enum . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
enums in switch Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1056
The Mystery of values() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057
Implements, not Inherits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1061
Random Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1062
Using Interfaces for Organization . . . . . . . . . . . . . . . . . . . . . . . . . 1063
Using EnumSet Instead of Flags . . . . . . . . . . . . . . . . . . . . . . . . . . 1070
Using EnumMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1072
Constant-Specific Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1074
Multiple Dispatching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1091
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1105

Annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1107
Basic Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1108
Writing Annotation Processors . . . . . . . . . . . . . . . . . . . . . . . . . . 1112
Using javac to Process Annotations . . . . . . . . . . . . . . . . . . . . . . . 1122
Annotation-Based Unit Testing . . . . . . . . . . . . . . . . . . . . . . . . . . 1132
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1159

Concurrent Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1160
The Terminology Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1161
Concurrency Superpowers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165
Concurrency is for Speed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1168
The Four Maxims of Java Concurrency . . . . . . . . . . . . . . . . . . . . . 1170
The Brutal Truth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1174
The Rest of the Chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1176
Parallel Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1178
Creating and Running Tasks . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1192
Terminating Long-Running Tasks . . . . . . . . . . . . . . . . . . . . . . . . . 1206
CompletableFutures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1209
Deadlock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1234
Constructors are not Thread-Safe . . . . . . . . . . . . . . . . . . . . . . . . . 1240
Effort, Complexity, Cost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1245
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1254

Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1259
The Pattern Concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1259
Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1261
Classifying Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1266
Template Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1267
Fronting for an Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . 1269
Factories: Encapsulating Object Creation . . . . . . . . . . . . . . . . . . . . 1277
Function Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1287
Changing the Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1295
Interpreter: Run-Time Flexibility . . . . . . . . . . . . . . . . . . . . . . . . . 1299
Callbacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1300
Multiple Dispatching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1308
Pattern Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1314
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1352

Appendix: Supplements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1354
On Java 8 Example Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1354
Thinking in C: Foundations for Java . . . . . . . . . . . . . . . . . . . . . . . 1354
Hands-On Java eSeminar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1354

Appendix: Programming Guidelines . . . . . . . . . . . . . . . . . . . . . . . . . 1355
Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1355
Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1361

Appendix: Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1367
Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1367
Embedded HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1368
Some Example Tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1369
Documentation Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1372

Appendix: Passing and Returning Objects . . . . . . . . . . . . . . . . . . . . . 1374
Passing References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1374
Making Local Copies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1378
Controlling Cloneability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1397
Immutable Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1409
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1419

Appendix: I/O Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1421
Types of InputStream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1422
Types of OutputStream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1424
Adding Attributes and Useful Interfaces . . . . . . . . . . . . . . . . . . . . . 1426
Readers & Writers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1429
Off By Itself: RandomAccessFile . . . . . . . . . . . . . . . . . . . . . . . . . 1433
Typical Uses of I/O Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1434
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1444

Appendix: Standard I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1445
Reading from Standard Input . . . . . . . . . . . . . . . . . . . . . . . . . . . 1445
Changing System.out to a PrintWriter . . . . . . . . . . . . . . . . . . . . 1446
Redirecting Standard I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1447
Process Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1449

Appendix: New I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1452
ByteBuffers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1452
Converting Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1457
Fetching Primitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1461
View Buffers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1463
Data Manipulation with Buffers . . . . . . . . . . . . . . . . . . . . . . . . . . 1468
Memory-Mapped Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1473
File Locking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1478

Appendix: Understanding equals() and hashCode() . . . . . . . . . . . . . . 1483
A Canonical equals() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1483
Hashing and Hash Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1494
Tuning a HashMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1512

Appendix: Collection Topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1514
Sample Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1514
List Behavior . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1523
Set Behavior . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1527
Using Functional Operations with any Map . . . . . . . . . . . . . . . . . . . 1530
Selecting Parts of a Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1532
Filling Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1534
Custom Collection and Map using Flyweight . . . . . . . . . . . . . . . . . 1541
Collection Functionality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1554
Optional Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1560
Sets and Storage Order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1564
Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1570
Understanding Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1574
Utilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1583
Holding References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1593
Java 1.0/1.1 Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1599
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1605

Appendix: Low-Level Concurrency . . . . . . . . . . . . . . . . . . . . . . . . . 1607
What is a Thread? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1607
Catching Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1613
Sharing Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1618
The volatile Keyword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1627
Atomicity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1631
Critical Sections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1642
Library Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1650
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1660

Appendix: Data Compression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1661
Simple Compression with GZIP . . . . . . . . . . . . . . . . . . . . . . . . . . 1662
Multifile Storage with Zip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1663
Java Archives (Jars) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1666

Appendix: Object Serialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1669
Finding the Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1674
Controlling Serialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1675
Using Persistence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1686

Appendix: Benefits and Costs of Static Type Checking . . . . . . . . . . . . . 1699
Foreword to the 2021 Edition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1699
Foreword to the Original Edition . . . . . . . . . . . . . . . . . . . . . . . . . 1700
Static Type Checking vs. Testing . . . . . . . . . . . . . . . . . . . . . . . . . 1701
How to Argue about Typing . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1710
The Cost of Productivity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1727
Static vs. Dynamic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1731

Appendix: The Positive Legacy of C++ and Java . . . . . . . . . . . . . . . . . 1739

Appendix: Becoming a Programmer . . . . . . . . . . . . . . . . . . . . . . . . . 1742
How I Got Started in Programming . . . . . . . . . . . . . . . . . . . . . . . . 1742
A Career in Computing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1744
The Mythical 5% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1748
Writing Software Is Like … Writing . . . . . . . . . . . . . . . . . . . . . . . . 1753
Programming as Typing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1756
Do What You Love . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1761
[/spoiler]