Core Java Volume I--Fundamentals, 10th Edition

【实例截图】

【核心代码】

Contents
xix Preface ..........................................................................................................
xxv Acknowledgments .........................................................................................
1 Chapter 1: An Introduction to Java ...............................................................
1 Java as a Programming Platform ............................................................... 1.1
2 The Java “White Paper” Buzzwords .......................................................... 1.2
3 Simple ............................................................................................. 1.2.1
4 Object-Oriented ............................................................................. 1.2.2
4 Distributed ..................................................................................... 1.2.3
4 Robust ............................................................................................. 1.2.4
4 Secure .............................................................................................. 1.2.5
5 Architecture-Neutral ..................................................................... 1.2.6
6 Portable ........................................................................................... 1.2.7
7 Interpreted ...................................................................................... 1.2.8
7 High-Performance ......................................................................... 1.2.9
7 Multithreaded ................................................................................ 1.2.10
8 Dynamic .......................................................................................... 1.2.11
8 Java Applets and the Internet ..................................................................... 1.3
10 A Short History of Java ............................................................................. 1.4
13 Common Misconceptions about Java ..................................................... 1.5
17 Chapter 2:The Java Programming Environment .......................................
18 Installing the Java Development Kit ....................................................... 2.1
18 Downloading the JDK ................................................................. 2.1.1
20 Setting up the JDK ....................................................................... 2.1.2
22 Installing Source Files and Documentation ............................. 2.1.3
23 Using the Command-Line Tools .............................................................. 2.2
26 Using an Integrated Development Environment .................................. 2.3
30 Running a Graphical Application ........................................................... 2.4
33 Building and Running Applets ................................................................ 2.5
v
www.allitebooks.com
41 Chapter 3: Fundamental Programming Structures in Java .......................
42 A Simple Java Program ............................................................................. 3.1
46 Comments ................................................................................................... 3.2
47 Data Types ................................................................................................... 3.3
47 Integer Types ................................................................................ 3.3.1
48 Floating-Point Types ................................................................... 3.3.2
50 The char Type ................................................................................ 3.3.3
51 Unicode and the char Type .......................................................... 3.3.4
52 The boolean Type ............................................................................ 3.3.5
53 Variables ...................................................................................................... 3.4
54 Initializing Variables ................................................................... 3.4.1
55 Constants ...................................................................................... 3.4.2
56 Operators .................................................................................................... 3.5
57 Mathematical Functions and Constants ................................... 3.5.1
59 Conversions between Numeric Types ...................................... 3.5.2
60 Casts .............................................................................................. 3.5.3
61 Combining Assignment with Operators .................................. 3.5.4
61 Increment and Decrement Operators ....................................... 3.5.5
62 Relational and boolean Operators ................................................ 3.5.6
63 Bitwise Operators ........................................................................ 3.5.7
64 Parentheses and Operator Hierarchy ....................................... 3.5.8
65 Enumerated Types ...................................................................... 3.5.9
65 Strings .......................................................................................................... 3.6
66 Substrings ..................................................................................... 3.6.1
66 Concatenation .............................................................................. 3.6.2
67 Strings Are Immutable ................................................................ 3.6.3
68 Testing Strings for Equality ........................................................ 3.6.4
69 Empty and Null Strings .............................................................. 3.6.5
70 Code Points and Code Units ...................................................... 3.6.6
71 The String API ................................................................................ 3.6.7
74 Reading the Online API Documentation ................................. 3.6.8
77 Building Strings ........................................................................... 3.6.9
78 Input and Output ....................................................................................... 3.7
79 Reading Input .............................................................................. 3.7.1
82 Formatting Output ...................................................................... 3.7.2
Contents vi
www.allitebooks.com
87 File Input and Output ................................................................. 3.7.3
89 Control Flow ............................................................................................... 3.8
89 Block Scope ................................................................................... 3.8.1
90 Conditional Statements .............................................................. 3.8.2
94 Loops ............................................................................................. 3.8.3
99 Determinate Loops ...................................................................... 3.8.4
103 Multiple Selections—The switch Statement ............................. 3.8.5
106 Statements That Break Control Flow ...................................... 3.8.6
108 Big Numbers ............................................................................................. 3.9
111 Arrays ........................................................................................................ 3.10
113 The “for each” Loop .................................................................. 3.10.1
114 Array Initializers and Anonymous Arrays ............................ 3.10.2
114 Array Copying ........................................................................... 3.10.3
116 Command-Line Parameters ..................................................... 3.10.4
117 Array Sorting ............................................................................. 3.10.5
120 Multidimensional Arrays ......................................................... 3.10.6
124 Ragged Arrays ........................................................................... 3.10.7
129 Chapter 4: Objects and Classes ................................................................
130 Introduction to Object-Oriented Programming .................................. 4.1
131 Classes ......................................................................................... 4.1.1
132 Objects ......................................................................................... 4.1.2
133 Identifying Classes .................................................................... 4.1.3
133 Relationships between Classes ................................................ 4.1.4
135 Using Predefined Classes ....................................................................... 4.2
136 Objects and Object Variables .................................................... 4.2.1
139 The LocalDate Class of the Java Library ..................................... 4.2.2
141 Mutator and Accessor Methods .............................................. 4.2.3
145 Defining Your Own Classes ................................................................... 4.3
145 An Employee Class ......................................................................... 4.3.1
149 Use of Multiple Source Files .................................................... 4.3.2
149 Dissecting the Employee Class ...................................................... 4.3.3
150 First Steps with Constructors .................................................. 4.3.4
152 Implicit and Explicit Parameters ............................................. 4.3.5
153 Benefits of Encapsulation ......................................................... 4.3.6
156 Class-Based Access Privileges .................................................. 4.3.7
vii Contents
www.allitebooks.com
156 Private Methods ......................................................................... 4.3.8
157 Final Instance Fields .................................................................. 4.3.9
158 Static Fields and Methods ....................................................................... 4.4
158 Static Fields ................................................................................. 4.4.1
159 Static Constants .......................................................................... 4.4.2
160 Static Methods ............................................................................ 4.4.3
161 Factory Methods ........................................................................ 4.4.4
161 The main Method ......................................................................... 4.4.5
164 Method Parameters .................................................................................. 4.5
171 Object Construction ................................................................................. 4.6
172 Overloading ................................................................................ 4.6.1
172 Default Field Initialization ....................................................... 4.6.2
173 The Constructor with No Arguments ..................................... 4.6.3
174 Explicit Field Initialization ....................................................... 4.6.4
175 Parameter Names ...................................................................... 4.6.5
176 Calling Another Constructor ................................................... 4.6.6
177 Initialization Blocks ................................................................... 4.6.7
181 Object Destruction and the finalize Method ........................... 4.6.8
182 Packages .................................................................................................... 4.7
183 Class Importation ...................................................................... 4.7.1
185 Static Imports ............................................................................. 4.7.2
185 Addition of a Class into a Package ......................................... 4.7.3
189 Package Scope ............................................................................ 4.7.4
190 The Class Path ........................................................................................... 4.8
193 Setting the Class Path ................................................................ 4.8.1
194 Documentation Comments .................................................................... 4.9
194 Comment Insertion ................................................................... 4.9.1
195 Class Comments ........................................................................ 4.9.2
195 Method Comments ................................................................... 4.9.3
196 Field Comments ........................................................................ 4.9.4
196 General Comments ................................................................... 4.9.5
198 Package and Overview Comments ......................................... 4.9.6
198 Comment Extraction ................................................................. 4.9.7
200 Class Design Hints .................................................................................. 4.10
Contents viii
www.allitebooks.com
203 Chapter 5: Inheritance ................................................................................
204 Classes, Superclasses, and Subclasses .................................................. 5.1
204 Defining Subclasses ................................................................... 5.1.1
206 Overriding Methods ................................................................. 5.1.2
207 Subclass Constructors ............................................................... 5.1.3
212 Inheritance Hierarchies ............................................................ 5.1.4
213 Polymorphism ............................................................................ 5.1.5
214 Understanding Method Calls .................................................. 5.1.6
217 Preventing Inheritance: Final Classes and Methods ............ 5.1.7
219 Casting ........................................................................................ 5.1.8
221 Abstract Classes ......................................................................... 5.1.9
227 Protected Access ........................................................................ 5.1.10
228 Object : The Cosmic Superclass ................................................................. 5.2
229 The equals Method ...................................................................... 5.2.1
231 Equality Testing and Inheritance ............................................. 5.2.2
235 The hashCode Method .................................................................... 5.2.3
238 The toString Method .................................................................... 5.2.4
244 Generic Array Lists .................................................................................. 5.3
247 Accessing Array List Elements ................................................ 5.3.1
251 Compatibility between Typed and Raw Array Lists ............ 5.3.2
252 Object Wrappers and Autoboxing ......................................................... 5.4
256 Methods with a Variable Number of Parameters ................................ 5.5
258 Enumeration Classes ............................................................................... 5.6
260 Reflection .................................................................................................. 5.7
261 The Class Class ............................................................................ 5.7.1
263 A Primer on Catching Exceptions ........................................... 5.7.2
265 Using Reflection to Analyze the Capabilities of Classes ...... 5.7.3
271 Using Reflection to Analyze Objects at Runtime .................. 5.7.4
276 Using Reflection to Write Generic Array Code ..................... 5.7.5
279 Invoking Arbitrary Methods ................................................... 5.7.6
283 Design Hints for Inheritance .................................................................. 5.8
287 Chapter 6: Interfaces, Lambda Expressions, and Inner Classes ............
288 Interfaces ................................................................................................... 6.1
288 The Interface Concept ............................................................... 6.1.1
ix Contents
www.allitebooks.com
295 Properties of Interfaces ............................................................. 6.1.2
297 Interfaces and Abstract Classes ............................................... 6.1.3
298 Static Methods ............................................................................ 6.1.4
298 Default Methods ........................................................................ 6.1.5
300 Resolving Default Method Conflicts ....................................... 6.1.6
302 Examples of Interfaces ............................................................................ 6.2
302 Interfaces and Callbacks ........................................................... 6.2.1
305 The Comparator Interface ................................................................ 6.2.2
306 Object Cloning ........................................................................... 6.2.3
314 Lambda Expressions ............................................................................... 6.3
314 Why Lambdas? .......................................................................... 6.3.1
315 The Syntax of Lambda Expressions ........................................ 6.3.2
318 Functional Interfaces ................................................................. 6.3.3
319 Method References .................................................................... 6.3.4
321 Constructor References ............................................................. 6.3.5
322 Variable Scope ............................................................................ 6.3.6
324 Processing Lambda Expressions ............................................. 6.3.7
328 More about Comparators ......................................................... 6.3.8
329 Inner Classes ............................................................................................. 6.4
331 Use of an Inner Class to Access Object State ......................... 6.4.1
334 Special Syntax Rules for Inner Classes ................................... 6.4.2
335 Are Inner Classes Useful? Actually Necessary? Secure? ...... 6.4.3
339 Local Inner Classes .................................................................... 6.4.4
339 Accessing Variables from Outer Methods .............................. 6.4.5
342 Anonymous Inner Classes ....................................................... 6.4.6
346 Static Inner Classes .................................................................... 6.4.7
350 Proxies ....................................................................................................... 6.5
350 When to Use Proxies ................................................................. 6.5.1
350 Creating Proxy Objects ............................................................. 6.5.2
355 Properties of Proxy Classes ...................................................... 6.5.3
357 Chapter 7: Exceptions,Assertions, and Logging .....................................
358 Dealing with Errors ................................................................................. 7.1
359 The Classification of Exceptions .............................................. 7.1.1
361 Declaring Checked Exceptions ................................................ 7.1.2
364 How to Throw an Exception .................................................... 7.1.3
Contents x
365 Creating Exception Classes ...................................................... 7.1.4
367 Catching Exceptions ................................................................................ 7.2
367 Catching an Exception .............................................................. 7.2.1
369 Catching Multiple Exceptions ................................................. 7.2.2
370 Rethrowing and Chaining Exceptions ................................... 7.2.3
372 The finally Clause ....................................................................... 7.2.4
376 The Try-with-Resources Statement ......................................... 7.2.5
377 Analyzing Stack Trace Elements .............................................. 7.2.6
381 Tips for Using Exceptions ....................................................................... 7.3
384 Using Assertions ...................................................................................... 7.4
384 The Assertion Concept .............................................................. 7.4.1
385 Assertion Enabling and Disabling .......................................... 7.4.2
386 Using Assertions for Parameter Checking ............................. 7.4.3
387 Using Assertions for Documenting Assumptions ................ 7.4.4
389 Logging ..................................................................................................... 7.5
389 Basic Logging ............................................................................. 7.5.1
390 Advanced Logging .................................................................... 7.5.2
392 Changing the Log Manager Configuration ........................... 7.5.3
393 Localization ................................................................................ 7.5.4
394 Handlers ..................................................................................... 7.5.5
398 Filters ........................................................................................... 7.5.6
399 Formatters .................................................................................. 7.5.7
399 A Logging Recipe ...................................................................... 7.5.8
409 Debugging Tips ........................................................................................ 7.6
415 Chapter 8: Generic Programming ..............................................................
416 Why Generic Programming? .................................................................. 8.1
416 The Advantage of Type Parameters ......................................... 8.1.1
417 Who Wants to Be a Generic Programmer? ............................. 8.1.2
418 Defining a Simple Generic Class ........................................................... 8.2
421 Generic Methods ...................................................................................... 8.3
422 Bounds for Type Variables ...................................................................... 8.4
425 Generic Code and the Virtual Machine ................................................ 8.5
425 Type Erasure .............................................................................. 8.5.1
426 Translating Generic Expressions ............................................. 8.5.2
427 Translating Generic Methods .................................................. 8.5.3
xi Contents
429 Calling Legacy Code ................................................................. 8.5.4
430 Restrictions and Limitations .................................................................. 8.6
430
Type Parameters Cannot Be Instantiated with Primitive
Types ...........................................................................................
8.6.1
431 Runtime Type Inquiry Only Works with Raw Types ........... 8.6.2
431 You Cannot Create Arrays of Parameterized Types ............ 8.6.3
432 Varargs Warnings ...................................................................... 8.6.4
433 You Cannot Instantiate Type Variables .................................. 8.6.5
434 You Cannot Construct a Generic Array ................................. 8.6.6
436
Type Variables Are Not Valid in Static Contexts of Generic
Classes .........................................................................................
8.6.7
436 You Cannot Throw or Catch Instances of a Generic Class ... 8.6.8
437 You Can Defeat Checked Exception Checking ..................... 8.6.9
439 Beware of Clashes after Erasure .............................................. 8.6.10
440 Inheritance Rules for Generic Types ..................................................... 8.7
442 Wildcard Types ........................................................................................ 8.8
442 The Wildcard Concept .............................................................. 8.8.1
444 Supertype Bounds for Wildcards ............................................ 8.8.2
447 Unbounded Wildcards ............................................................. 8.8.3
448 Wildcard Capture ...................................................................... 8.8.4
450 Reflection and Generics .......................................................................... 8.9
450 The Generic Class Class .............................................................. 8.9.1
452 Using Class<T> Parameters for Type Matching ........................ 8.9.2
452 Generic Type Information in the Virtual Machine ................ 8.9.3
459 Chapter 9: Collections ................................................................................
460 The Java Collections Framework ........................................................... 9.1
460 Separating Collection Interfaces and Implementation ......... 9.1.1
463 The Collection Interface ................................................................ 9.1.2
463 Iterators ....................................................................................... 9.1.3
466 Generic Utility Methods ........................................................... 9.1.4
469 Interfaces in the Collections Framework ............................... 9.1.5
472 Concrete Collections ................................................................................ 9.2
474 Linked Lists ................................................................................ 9.2.1
484 Array Lists .................................................................................. 9.2.2
485 Hash Sets .................................................................................... 9.2.3
Contents xii
489 Tree Sets ...................................................................................... 9.2.4
494 Queues and Deques .................................................................. 9.2.5
495 Priority Queues .......................................................................... 9.2.6
497 Maps .......................................................................................................... 9.3
497 Basic Map Operations ............................................................... 9.3.1
500 Updating Map Entries .............................................................. 9.3.2
502 Map Views .................................................................................. 9.3.3
504 Weak Hash Maps ....................................................................... 9.3.4
504 Linked Hash Sets and Maps .................................................... 9.3.5
506 Enumeration Sets and Maps .................................................... 9.3.6
507 Identity Hash Maps .................................................................. 9.3.7
509 Views and Wrappers ............................................................................... 9.4
509 Lightweight Collection Wrappers ........................................... 9.4.1
510 Subranges ................................................................................... 9.4.2
511 Unmodifiable Views ................................................................. 9.4.3
512 Synchronized Views .................................................................. 9.4.4
513 Checked Views .......................................................................... 9.4.5
514 A Note on Optional Operations .............................................. 9.4.6
517 Algorithms ................................................................................................ 9.5
518 Sorting and Shuffling ................................................................ 9.5.1
521 Binary Search ............................................................................. 9.5.2
522 Simple Algorithms .................................................................... 9.5.3
524 Bulk Operations ......................................................................... 9.5.4
525 Converting between Collections and Arrays ........................ 9.5.5
526 Writing Your Own Algorithms ................................................ 9.5.6
528 Legacy Collections ................................................................................... 9.6
528 The Hashtable Class ....................................................................... 9.6.1
528 Enumerations ............................................................................. 9.6.2
530 Property Maps ........................................................................... 9.6.3
531 Stacks ........................................................................................... 9.6.4
532 Bit Sets ......................................................................................... 9.6.5
537 Chapter 10: Graphics Programming ..........................................................
538 Introducing Swing ................................................................................... 10.1
543 Creating a Frame ...................................................................................... 10.2
546 Positioning a Frame ................................................................................. 10.3
xiii Contents
549 Frame Properties ....................................................................... 10.3.1
549 Determining a Good Frame Size ............................................. 10.3.2
554 Displaying Information in a Component ............................................. 10.4
560 Working with 2D Shapes ........................................................................ 10.5
569 Using Color ............................................................................................... 10.6
573 Using Special Fonts for Text ................................................................... 10.7
582 Displaying Images ................................................................................... 10.8
587 Chapter 11: Event Handling ........................................................................
587 Basics of Event Handling ........................................................................ 11.1
591 Example: Handling a Button Click ......................................... 11.1.1
595 Specifying Listeners Concisely ................................................ 11.1.2
598 Example: Changing the Look-and-Feel .................................. 11.1.3
603 Adapter Classes ......................................................................... 11.1.4
607 Actions ....................................................................................................... 11.2
616 Mouse Events ........................................................................................... 11.3
624 The AWT Event Hierarchy ..................................................................... 11.4
626 Semantic and Low-Level Events ............................................. 11.4.1
629 Chapter 12: User Interface Components with Swing ...............................
630 Swing and the Model-View-Controller Design Pattern ..................... 12.1
630 Design Patterns .......................................................................... 12.1.1
632 The Model-View-Controller Pattern ....................................... 12.1.2
636 A Model-View-Controller Analysis of Swing Buttons ......... 12.1.3
638 Introduction to Layout Management .................................................... 12.2
641 Border Layout ............................................................................ 12.2.1
644 Grid Layout ................................................................................ 12.2.2
648 Text Input .................................................................................................. 12.3
649 Text Fields ................................................................................... 12.3.1
651 Labels and Labeling Components .......................................... 12.3.2
652 Password Fields ......................................................................... 12.3.3
653 Text Areas ................................................................................... 12.3.4
654 Scroll Panes ................................................................................. 12.3.5
657 Choice Components ................................................................................ 12.4
657 Checkboxes ................................................................................. 12.4.1
660 Radio Buttons ............................................................................. 12.4.2
Contents xiv
664 Borders ........................................................................................ 12.4.3
668 Combo Boxes .............................................................................. 12.4.4
672 Sliders .......................................................................................... 12.4.5
678 Menus ........................................................................................................ 12.5
679 Menu Building ........................................................................... 12.5.1
682 Icons in Menu Items .................................................................. 12.5.2
683 Checkbox and Radio Button Menu Items .............................. 12.5.3
684 Pop-Up Menus ........................................................................... 12.5.4
686 Keyboard Mnemonics and Accelerators ................................ 12.5.5
689 Enabling and Disabling Menu Items ...................................... 12.5.6
694 Toolbars ....................................................................................... 12.5.7
696 Tooltips ........................................................................................ 12.5.8
699 Sophisticated Layout Management ....................................................... 12.6
701 The Grid Bag Layout ................................................................. 12.6.1
703 The gridx , gridy , gridwidth , and gridheight Parameters ... 12.6.1.1
703 Weight Fields .............................................................. 12.6.1.2
704 The fill and anchor Parameters .................................. 12.6.1.3
704 Padding ....................................................................... 12.6.1.4
705
Alternative Method to Specify the gridx , gridy ,
gridwidth , and gridheight Parameters ............................
12.6.1.5
706
A Helper Class to Tame the Grid Bag
Constraints ..................................................................
12.6.1.6
713 Group Layout ............................................................................. 12.6.2
723 Using No Layout Manager ...................................................... 12.6.3
724 Custom Layout Managers ........................................................ 12.6.4
729 Traversal Order .......................................................................... 12.6.5
730 Dialog Boxes ............................................................................................. 12.7
731 Option Dialogs ........................................................................... 12.7.1
741 Creating Dialogs ........................................................................ 12.7.2
746 Data Exchange ............................................................................ 12.7.3
752 File Dialogs ................................................................................. 12.7.4
764 Color Choosers .......................................................................... 12.7.5
770 Troubleshooting GUI Programs ............................................................. 12.8
770 Debugging Tips ......................................................................... 12.8.1
774 Letting the AWT Robot Do the Work ..................................... 12.8.2
xv Contents
779 Chapter 13: Deploying Java Applications .................................................
780 JAR Files .................................................................................................... 13.1
780 Creating JAR files ...................................................................... 13.1.1
781 The Manifest ............................................................................... 13.1.2
782 Executable JAR Files ................................................................. 13.1.3
783 Resources .................................................................................... 13.1.4
787 Sealing ......................................................................................... 13.1.5
788 Storage of Application Preferences ....................................................... 13.2
788 Property Maps ........................................................................... 13.2.1
794 The Preferences API .................................................................. 13.2.2
800 Service Loaders ........................................................................................ 13.3
802 Applets ...................................................................................................... 13.4
803 A Simple Applet ........................................................................ 13.4.1
808 The applet HTML Tag and Its Attributes ................................. 13.4.2
810 Use of Parameters to Pass Information to Applets ............... 13.4.3
816 Accessing Image and Audio Files ........................................... 13.4.4
818 The Applet Context ................................................................... 13.4.5
818 Inter-Applet Communication .................................................. 13.4.6
819 Displaying Items in the Browser ............................................. 13.4.7
820 The Sandbox ............................................................................... 13.4.8
822 Signed Code ............................................................................... 13.4.9
824 Java Web Start ........................................................................................... 13.5
824 Delivering a Java Web Start Application ................................ 13.5.1
829 The JNLP API ............................................................................. 13.5.2
839 Chapter 14: Concurrency ...........................................................................
840 What Are Threads? .................................................................................. 14.1
846 Using Threads to Give Other Tasks a Chance ....................... 14.1.1
851 Interrupting Threads ............................................................................... 14.2
855 Thread States ............................................................................................. 14.3
855 New Threads .............................................................................. 14.3.1
855 Runnable Threads ...................................................................... 14.3.2
856 Blocked and Waiting Threads .................................................. 14.3.3
857 Terminated Threads .................................................................. 14.3.4
858 Thread Properties ..................................................................................... 14.4
858 Thread Priorities ........................................................................ 14.4.1
Contents xvi
859 Daemon Threads ........................................................................ 14.4.2
860 Handlers for Uncaught Exceptions ........................................ 14.4.3
862 Synchronization ....................................................................................... 14.5
862 An Example of a Race Condition ............................................ 14.5.1
866 The Race Condition Explained ................................................ 14.5.2
868 Lock Objects ............................................................................... 14.5.3
872 Condition Objects ...................................................................... 14.5.4
878 The synchronized Keyword ............................................................ 14.5.5
882 Synchronized Blocks ................................................................. 14.5.6
884 The Monitor Concept ................................................................ 14.5.7
885 Volatile Fields ............................................................................. 14.5.8
886 Final Variables ............................................................................ 14.5.9
886 Atomics ....................................................................................... 14.5.10
889 Deadlocks ................................................................................... 14.5.11
892 Thread-Local Variables ............................................................. 14.5.12
893 Lock Testing and Timeouts ...................................................... 14.5.13
895 Read/Write Locks ..................................................................... 14.5.14
896 Why the stop and suspend Methods Are Deprecated ............... 14.5.15
898 Blocking Queues ...................................................................................... 14.6
905 Thread-Safe Collections .......................................................................... 14.7
905 Efficient Maps, Sets, and Queues ............................................ 14.7.1
907 Atomic Update of Map Entries ................................................ 14.7.2
909 Bulk Operations on Concurrent Hash Maps ......................... 14.7.3
912 Concurrent Set Views ............................................................... 14.7.4
912 Copy on Write Arrays ............................................................... 14.7.5
912 Parallel Array Algorithms ........................................................ 14.7.6
914 Older Thread-Safe Collections ................................................. 14.7.7
915 Callables and Futures .............................................................................. 14.8
920 Executors ................................................................................................... 14.9
921 Thread Pools ............................................................................... 14.9.1
926 Scheduled Execution ................................................................. 14.9.2
927 Controlling Groups of Tasks .................................................... 14.9.3
928 The Fork-Join Framework ........................................................ 14.9.4
931 Completable Futures ................................................................. 14.9.5
934 Synchronizers ........................................................................................... 14.10
xvii Contents
935 Semaphores ................................................................................ 14.10.1
936 Countdown Latches .................................................................. 14.10.2
936 Barriers ........................................................................................ 14.10.3
937 Exchangers ................................................................................. 14.10.4
937 Synchronous Queues ................................................................ 14.10.5
937 Threads and Swing .................................................................................. 14.11
939 Running Time-Consuming Tasks ............................................ 14.11.1
943 Using the Swing Worker .......................................................... 14.11.2
951 The Single-Thread Rule ............................................................ 14.11.3
953 Appendix ......................................................................................................
957