Core Java vol 1 & 2 for the impatient and effective PACK 12th ed

Title Page
Contents
Table of Contents
Preface
Acknowledgments
About the Author
Chapter 1. Fundamental Programming Structures
	1.1. Our First Program
	1.2. Primitive Types
	1.3. Variables
	1.4. Arithmetic Operations
	1.5. Strings
	1.6. Input and Output
	1.7. Control Flow
	1.8. Arrays and Array Lists
	1.9. Functional Decomposition
	Exercises
Chapter 2. Object-Oriented Programming
	2.1. Working with Objects
	2.2. Implementing Classes
	2.3. Object Construction
	2.4. Records
	2.5. Static Variables and Methods
	2.6. Packages
	2.7. Nested Classes
	2.8. Documentation Comments
	Exercises
Chapter 3. Interfaces and Lambda Expressions
	3.1. Interfaces
	3.2. Static, Default, and Private Methods
	3.3. Examples of Interfaces
	3.4. Lambda Expressions
	3.5. Method and Constructor References
	3.6. Processing Lambda Expressions
	3.7. Lambda Expressions and Variable Scope
	3.8. Higher-Order Functions
	3.9. Local and Anonymous Classes
	Exercises
Chapter 4. Inheritance and Reflection
	4.1. Extending a Class
	4.2. Inheritance Hierarchies
	4.3. Object: The Cosmic Superclass
	4.4. Enumerations
	4.5. Runtime Type Information and Resources
	4.6. Reflection
	Exercises
Chapter 5. Exceptions, Assertions, and Logging
	5.1. Exception Handling
	5.2. Assertions
	5.3. Logging
	Exercises
Chapter 6. Generic Programming
	6.1. Generic Classes
	6.2. Generic Methods
	6.3. Type Bounds
	6.4. Type Variance and Wildcards
	6.5. Generics in the Java Virtual Machine
	6.6. Restrictions on Generics
	6.7. Reflection and Generics
	Exercises
Chapter 7. Collections
	7.1. An Overview of the Collections Framework
	7.2. Iterators
	7.3. Sets
	7.4. Maps
	7.5. Other Collections
	7.6. Views
	Exercises
Chapter 8. Streams
	8.1. From Iterating to Stream Operations
	8.2. Stream Creation
	8.3. The filter, map, and flatMap Methods
	8.4. Extracting Substreams and Combining Streams
	8.5. Other Stream Transformations
	8.6. Simple Reductions
	8.7. The Optional Type
	8.8. Collecting Results
	8.9. Collecting into Maps
	8.10. Grouping and Partitioning
	8.11. Downstream Collectors
	8.12. Reduction Operations
	8.13. Primitive Type Streams
	8.14. Parallel Streams
	Exercises
Chapter 9. Processing Input and Output
	9.1. Input/Output Streams, Readers, and Writers
	9.2. Paths, Files, and Directories
	9.3. HTTP Connections
	9.4. Regular Expressions
	9.5. Serialization
	Exercises
Chapter 10. Concurrent Programming
	10.1. Concurrent Tasks
	10.2. Asynchronous Computations
	10.3. Thread Safety
	10.4. Parallel Algorithms
	10.5. Threadsafe Data Structures
	10.6. Atomic Counters and Accumulators
	10.7. Locks and Conditions
	10.8. Threads
	10.9. Processes
	Exercises
Chapter 11. Annotations
	11.1. Using Annotations
	11.2. Defining Annotations
	11.3. Standard Annotations
	11.4. Processing Annotations at Runtime
	11.5. Source-Level Annotation Processing
	Exercises
Chapter 12. The Date and Time API
	12.1. The Time Line
	12.2. Local Dates
	12.3. Date Adjusters
	12.4. Local Time
	12.5. Zoned Time
	12.6. Formatting and Parsing
	12.7. Interoperating with Legacy Code
	Exercises
Chapter 13. Internationalization
	13.1. Locales
	13.2. Number Formats
	13.3. Currencies
	13.4. Date and Time Formatting
	13.5. Collation and Normalization
	13.6. Message Formatting
	13.7. Resource Bundles
	13.8. Character Encodings
	13.9. Preferences
	Exercises
Chapter 14. Compiling and Scripting
	14.1. The Compiler API
	14.2. The Scripting API
	Exercises
Chapter 15. The Java Platform Module System
	15.1. The Module Concept
	15.2. Naming Modules
	15.3. The Modular “Hello, World!” Program
	15.4. Requiring Modules
	15.5. Exporting Packages
	15.6. Modules and Reflective Access
	15.7. Modular JARs
	15.8. Automatic Modules
	15.9. The Unnamed Module
	15.10. Command-Line Flags for Migration
	15.11. Transitive and Static Requirements
	15.12. Qualified Exporting and Opening
	15.13. Service Loading
	15.14. Tools for Working with Modules
	Exercises
Title Page
Contents
Table of Contents
Preface
Acknowledgments
Chapter 1: An Introduction to Java
	1.1 Java as a Programming Platform
	1.2 The Java “White Paper” Buzzwords
		1.2.1 Simple
		1.2.2 Object-Oriented
		1.2.3 Distributed
		1.2.4 Robust
		1.2.5 Secure
		1.2.6 Architecture-Neutral
		1.2.7 Portable
		1.2.8 Interpreted
		1.2.9 High-Performance
		1.2.10 Multithreaded
		1.2.11 Dynamic
	1.3 Java Applets and the Internet
	1.4 A Short History of Java
	1.5 Common Misconceptions about Java
Chapter 2: The Java Programming Environment
	2.1 Installing the Java Development Kit
		2.1.1 Downloading the JDK
		2.1.2 Setting up the JDK
		2.1.3 Installing Source Files and Documentation
	2.2 Using the Command-Line Tools
	2.3 Using an Integrated Development Environment
	2.4 JShell
Chapter 3: Fundamental Programming Structures in Java
	3.1 A Simple Java Program
	3.2 Comments
	3.3 Data Types
		3.3.1 Integer Types
		3.3.2 Floating-Point Types
		3.3.3 The char Type
		3.3.4 Unicode and the char Type
		3.3.5 The boolean Type
	3.4 Variables and Constants
		3.4.1 Declaring Variables
		3.4.2 Initializing Variables
		3.4.3 Constants
		3.4.4 Enumerated Types
	3.5 Operators
		3.5.1 Arithmetic Operators
		3.5.2 Mathematical Functions and Constants
		3.5.3 Conversions between Numeric Types
		3.5.4 Casts
		3.5.5 Assignment
		3.5.6 Increment and Decrement Operators
		3.5.7 Relational and boolean Operators
		3.5.8 The Conditional Operator
		3.5.9 Switch Expressions
		3.5.10 Bitwise Operators
		3.5.11 Parentheses and Operator Hierarchy
	3.6 Strings
		3.6.1 Substrings
		3.6.2 Concatenation
		3.6.3 Strings Are Immutable
		3.6.4 Testing Strings for Equality
		3.6.5 Empty and Null Strings
		3.6.6 Code Points and Code Units
		3.6.7 The String API
		3.6.8 Reading the Online API Documentation
		3.6.9 Building Strings
		3.6.10 Text Blocks
	3.7 Input and Output
		3.7.1 Reading Input
		3.7.2 Formatting Output
		3.7.3 File Input and Output
	3.8 Control Flow
		3.8.1 Block Scope
		3.8.2 Conditional Statements
		3.8.3 Loops
		3.8.4 Determinate Loops
		3.8.5 Multiple Selections with switch
		3.8.6 Statements That Break Control Flow
	3.9 Big Numbers
	3.10 Arrays
		3.10.1 Declaring Arrays
		3.10.2 Accessing Array Elements
		3.10.3 The “for each” Loop
		3.10.4 Array Copying
		3.10.5 Command-Line Parameters
		3.10.6 Array Sorting
		3.10.7 Multidimensional Arrays
		3.10.8 Ragged Arrays
Chapter 4: Objects and Classes
	4.1 Introduction to Object-Oriented Programming
		4.1.1 Classes
		4.1.2 Objects
		4.1.3 Identifying Classes
		4.1.4 Relationships between Classes
	4.2 Using Predefined Classes
		4.2.1 Objects and Object Variables
		4.2.2 The LocalDate Class of the Java Library
		4.2.3 Mutator and Accessor Methods
	4.3 Defining Your Own Classes
		4.3.1 An Employee Class
		4.3.2 Use of Multiple Source Files
		4.3.3 Dissecting the Employee Class
		4.3.4 First Steps with Constructors
		4.3.5 Declaring Local Variables with var
		4.3.6 Working with null References
		4.3.7 Implicit and Explicit Parameters
		4.3.8 Benefits of Encapsulation
		4.3.9 Class-Based Access Privileges
		4.3.10 Private Methods
		4.3.11 Final Instance Fields
	4.4 Static Fields and Methods
		4.4.1 Static Fields
		4.4.2 Static Constants
		4.4.3 Static Methods
		4.4.4 Factory Methods
		4.4.5 The main Method
	4.5 Method Parameters
	4.6 Object Construction
		4.6.1 Overloading
		4.6.2 Default Field Initialization
		4.6.3 The Constructor with No Arguments
		4.6.4 Explicit Field Initialization
		4.6.5 Parameter Names
		4.6.6 Calling Another Constructor
		4.6.7 Initialization Blocks
		4.6.8 Object Destruction and the finalize Method
	4.7 Records
		4.7.1 The Record Concept
		4.7.2 Constructors: Canonical, Custom, and Compact
	4.8 Packages
		4.8.1 Package Names
		4.8.2 Class Importation
		4.8.3 Static Imports
		4.8.4 Addition of a Class into a Package
		4.8.5 Package Access
		4.8.6 The Class Path
		4.8.7 Setting the Class Path
	4.9 JAR Files
		4.9.1 Creating JAR files
		4.9.2 The Manifest
		4.9.3 Executable JAR Files
		4.9.4 Multi-Release JAR Files
		4.9.5 A Note about Command-Line Options
	4.10 Documentation Comments
		4.10.1 Comment Insertion
		4.10.2 Class Comments
		4.10.3 Method Comments
		4.10.4 Field Comments
		4.10.5 General Comments
		4.10.6 Package Comments
		4.10.7 Comment Extraction
	4.11 Class Design Hints
Chapter 5: Inheritance
	5.1 Classes, Superclasses, and Subclasses
		5.1.1 Defining Subclasses
		5.1.2 Overriding Methods
		5.1.3 Subclass Constructors
		5.1.4 Inheritance Hierarchies
		5.1.5 Polymorphism
		5.1.6 Understanding Method Calls
		5.1.7 Preventing Inheritance: Final Classes and Methods
		5.1.8 Casting
		5.1.9 Pattern Matching for instanceof
		5.1.10 Protected Access
	5.2 Object: The Cosmic Superclass
		5.2.1 Variables of Type Object
		5.2.2 The equals Method
		5.2.3 Equality Testing and Inheritance
		5.2.4 The hashCode Method
		5.2.5 The toString Method
	5.3 Generic Array Lists
		5.3.1 Declaring Array Lists
		5.3.2 Accessing Array List Elements
		5.3.3 Compatibility between Typed and Raw Array Lists
	5.4 Object Wrappers and Autoboxing
	5.5 Methods with a Variable Number of Parameters
	5.6 Abstract Classes
	5.7 Enumeration Classes
	5.8 Sealed Classes
	5.9 Reflection
		5.9.1 The Class Class
		5.9.2 A Primer on Declaring Exceptions
		5.9.3 Resources
		5.9.4 Using Reflection to Analyze the Capabilities of Classes
		5.9.5 Using Reflection to Analyze Objects at Runtime
		5.9.6 Using Reflection to Write Generic Array Code
		5.9.7 Invoking Arbitrary Methods and Constructors
	5.10 Design Hints for Inheritance
Chapter 6: Interfaces, Lambda Expressions, and Inner Classes
	6.1 Interfaces
		6.1.1 The Interface Concept
		6.1.2 Properties of Interfaces
		6.1.3 Interfaces and Abstract Classes
		6.1.4 Static and Private Methods
		6.1.5 Default Methods
		6.1.6 Resolving Default Method Conflicts
		6.1.7 Interfaces and Callbacks
		6.1.8 The Comparator Interface
		6.1.9 Object Cloning
	6.2 Lambda Expressions
		6.2.1 Why Lambdas?
		6.2.2 The Syntax of Lambda Expressions
		6.2.3 Functional Interfaces
		6.2.4 Method References
		6.2.5 Constructor References
		6.2.6 Variable Scope
		6.2.7 Processing Lambda Expressions
		6.2.8 More about Comparators
	6.3 Inner Classes
		6.3.1 Use of an Inner Class to Access Object State
		6.3.2 Special Syntax Rules for Inner Classes
		6.3.3 Are Inner Classes Useful? Actually Necessary? Secure?
		6.3.4 Local Inner Classes
		6.3.5 Accessing Variables from Outer Methods
		6.3.6 Anonymous Inner Classes
		6.3.7 Static Inner Classes
	6.4 Service Loaders
	6.5 Proxies
		6.5.1 When to Use Proxies
		6.5.2 Creating Proxy Objects
		6.5.3 Properties of Proxy Classes
Chapter 7: Exceptions, Assertions, and Logging
	7.1 Dealing with Errors
		7.1.1 The Classification of Exceptions
		7.1.2 Declaring Checked Exceptions
		7.1.3 How to Throw an Exception
		7.1.4 Creating Exception Classes
	7.2 Catching Exceptions
		7.2.1 Catching an Exception
		7.2.2 Catching Multiple Exceptions
		7.2.3 Rethrowing and Chaining Exceptions
		7.2.4 The finally Clause
		7.2.5 The try-with-Resources Statement
		7.2.6 Analyzing Stack Trace Elements
	7.3 Tips for Using Exceptions
	7.4 Using Assertions
		7.4.1 The Assertion Concept
		7.4.2 Assertion Enabling and Disabling
		7.4.3 Using Assertions for Parameter Checking
		7.4.4 Using Assertions for Documenting Assumptions
	7.5 Logging
		7.5.1 Basic Logging
		7.5.2 Advanced Logging
		7.5.3 Changing the Log Manager Configuration
		7.5.4 Localization
		7.5.5 Handlers
		7.5.6 Filters
		7.5.7 Formatters
		7.5.8 A Logging Recipe
	7.6 Debugging Tips
Chapter 8: Generic Programming
	8.1 Why Generic Programming?
		8.1.1 The Advantage of Type Parameters
		8.1.2 Who Wants to Be a Generic Programmer?
	8.2 Defining a Simple Generic Class
	8.3 Generic Methods
	8.4 Bounds for Type Variables
	8.5 Generic Code and the Virtual Machine
		8.5.1 Type Erasure
		8.5.2 Translating Generic Expressions
		8.5.3 Translating Generic Methods
		8.5.4 Calling Legacy Code
	8.6 Restrictions and Limitations
		8.6.1 Type Parameters Cannot Be Instantiated with Primitive Types
		8.6.2 Runtime Type Inquiry Only Works with Raw Types
		8.6.3 You Cannot Create Arrays of Parameterized Types
		8.6.4 Varargs Warnings
		8.6.5 You Cannot Instantiate Type Variables
		8.6.6 You Cannot Construct a Generic Array
		8.6.7 Type Variables Are Not Valid in Static Contexts of Generic Classes
		8.6.8 You Cannot Throw or Catch Instances of a Generic Class
		8.6.9 You Can Defeat Checked Exception Checking
		8.6.10 Beware of Clashes after Erasure
	8.7 Inheritance Rules for Generic Types
	8.8 Wildcard Types
		8.8.1 The Wildcard Concept
		8.8.2 Supertype Bounds for Wildcards
		8.8.3 Unbounded Wildcards
		8.8.4 Wildcard Capture
	8.9 Reflection and Generics
		8.9.1 The Generic Class Class
		8.9.2 Using Class Parameters for Type Matching
		8.9.3 Generic Type Information in the Virtual Machine
		8.9.4 Type Literals
Chapter 9: Collections
	9.1 The Java Collections Framework
		9.1.1 Separating Collection Interfaces and Implementation
		9.1.2 The Collection Interface
		9.1.3 Iterators
		9.1.4 Generic Utility Methods
	9.2 Interfaces in the Collections Framework
	9.3 Concrete Collections
		9.3.1 Linked Lists
		9.3.2 Array Lists
		9.3.3 Hash Sets
		9.3.4 Tree Sets
		9.3.5 Queues and Deques
		9.3.6 Priority Queues
	9.4 Maps
		9.4.1 Basic Map Operations
		9.4.2 Updating Map Entries
		9.4.3 Map Views
		9.4.4 Weak Hash Maps
		9.4.5 Linked Hash Sets and Maps
		9.4.6 Enumeration Sets and Maps
		9.4.7 Identity Hash Maps
	9.5 Copies and Views
		9.5.1 Small Collections
		9.5.2 Unmodifiable Copies and Views
		9.5.3 Subranges
		9.5.4 Checked Views
		9.5.5 Synchronized Views
		9.5.6 A Note on Optional Operations
	9.6 Algorithms
		9.6.1 Why Generic Algorithms?
		9.6.2 Sorting and Shuffling
		9.6.3 Binary Search
		9.6.4 Simple Algorithms
		9.6.5 Bulk Operations
		9.6.6 Converting between Collections and Arrays
		9.6.7 Writing Your Own Algorithms
	9.7 Legacy Collections
		9.7.1 The Hashtable Class
		9.7.2 Enumerations
		9.7.3 Property Maps
		9.7.4 Stacks
		9.7.5 Bit Sets
Chapter 10: Graphical User Interface Programming
	10.1 A History of Java User Interface Toolkits
	10.2 Displaying Frames
		10.2.1 Creating a Frame
		10.2.2 Frame Properties
	10.3 Displaying Information in a Component
		10.3.1 Working with 2D Shapes
		10.3.2 Using Color
		10.3.3 Using Fonts
		10.3.4 Displaying Images
	10.4 Event Handling
		10.4.1 Basic Event Handling Concepts
		10.4.2 Example: Handling a Button Click
		10.4.3 Specifying Listeners Concisely
		10.4.4 Adapter Classes
		10.4.5 Actions
		10.4.6 Mouse Events
		10.4.7 The AWT Event Hierarchy
	10.5 The Preferences API
Chapter 11: User Interface Components with Swing
	11.1 Swing and the Model-View-Controller Design Pattern
	11.2 Introduction to Layout Management
		11.2.1 Layout Managers
		11.2.2 Border Layout
		11.2.3 Grid Layout
	11.3 Text Input
		11.3.1 Text Fields
		11.3.2 Labels and Labeling Components
		11.3.3 Password Fields
		11.3.4 Text Areas
		11.3.5 Scroll Panes
	11.4 Choice Components
		11.4.1 Checkboxes
		11.4.2 Radio Buttons
		11.4.3 Borders
		11.4.4 Combo Boxes
		11.4.5 Sliders
	11.5 Menus
		11.5.1 Menu Building
		11.5.2 Icons in Menu Items
		11.5.3 Checkbox and Radio Button Menu Items
		11.5.4 Pop-Up Menus
		11.5.5 Keyboard Mnemonics and Accelerators
		11.5.6 Enabling and Disabling Menu Items
		11.5.7 Toolbars
		11.5.8 Tooltips
	11.6 Sophisticated Layout Management
		11.6.1 The Grid Bag Layout
		11.6.2 Custom Layout Managers
	11.7 Dialog Boxes
		11.7.1 Option Dialogs
		11.7.2 Creating Dialogs
		11.7.3 Data Exchange
		11.7.4 File Dialogs
Chapter 12: Concurrency
	12.1 What Are Threads?
	12.2 Thread States
		12.2.1 New Threads
		12.2.2 Runnable Threads
		12.2.3 Blocked and Waiting Threads
		12.2.4 Terminated Threads
	12.3 Thread Properties
		12.3.1 Interrupting Threads
		12.3.2 Daemon Threads
		12.3.3 Thread Names
		12.3.4 Handlers for Uncaught Exceptions
		12.3.5 Thread Priorities
	12.4 Synchronization
		12.4.1 An Example of a Race Condition
		12.4.2 The Race Condition Explained
		12.4.3 Lock Objects
		12.4.4 Condition Objects
		12.4.5 The synchronized Keyword
		12.4.6 Synchronized Blocks
		12.4.7 The Monitor Concept
		12.4.8 Volatile Fields
		12.4.9 Final Variables
		12.4.10 Atomics
		12.4.11 Deadlocks
		12.4.12 Why the stop and suspend Methods Are Deprecated
		12.4.13 On-Demand Initialization
		12.4.14 Thread-Local Variables
	12.5 Thread-Safe Collections
		12.5.1 Blocking Queues
		12.5.2 Efficient Maps, Sets, and Queues
		12.5.3 Atomic Update of Map Entries
		12.5.4 Bulk Operations on Concurrent Hash Maps
		12.5.5 Concurrent Set Views
		12.5.6 Copy on Write Arrays
		12.5.7 Parallel Array Algorithms
		12.5.8 Older Thread-Safe Collections
	12.6 Tasks and Thread Pools
		12.6.1 Callables and Futures
		12.6.2 Executors
		12.6.3 Controlling Groups of Tasks
		12.6.4 The Fork-Join Framework
	12.7 Asynchronous Computations
		12.7.1 Completable Futures
		12.7.2 Composing Completable Futures
		12.7.3 Long-Running Tasks in User Interface Callbacks
	12.8 Processes
		12.8.1 Building a Process
		12.8.2 Running a Process
		12.8.3 Process Handles
Appendix
About This eBook
Halftitle Page
Title Page
Copyright Page
Pearson’s Commitment to Diversity, Equity, and Inclusion
Contents
Preface
	To the Reader
	About This Book
	Conventions
Acknowledgments
Chapter 1. Streams
	1.1 From Iterating to Stream Operations
	1.2 Stream Creation
	1.3 The filter, map, and flatMap Methods
	1.4 Extracting Substreams and Combining Streams
	1.5 Other Stream Transformations
	1.6 Simple Reductions
	1.7 The Optional Type
	1.8 Collecting Results
	1.9 Collecting into Maps
	1.10 Grouping and Partitioning
	1.11 Downstream Collectors
	1.12 Reduction Operations
	1.13 Primitive Type Streams
	1.14 Parallel Streams
Chapter 2. Input and Output
	2.1 Input/Output Streams
	2.2 Reading and Writing Binary Data
	2.3 Object Input/Output Streams and Serialization
	2.4 Working with Files
	2.5 Memory-Mapped Files
	2.6 File Locking
	2.7 Regular Expressions
Chapter 3. XML
	3.1 Introducing XML
	3.2 The Structure of an XML Document
	3.3 Parsing an XML Document
	3.4 Validating XML Documents
	3.5 Locating Information with XPath
	3.6 Using Namespaces
	3.7 Streaming Parsers
	3.8 Generating XML Documents
	3.9 XSL Transformations
Chapter 4. Networking
	4.1 Connecting to a Server
	4.2 Implementing Servers
	4.3 Getting Web Data
	4.4 The HTTP Client
	4.5 Sending E-Mail
Chapter 5. Database Programming
	5.1 The Design of JDBC
	5.2 The Structured Query Language
	5.3 JDBC Configuration
	5.4 Working with JDBC Statements
	5.5 Query Execution
	5.6 Scrollable and Updatable Result Sets
	5.7 Row Sets
	5.8 Metadata
	5.9 Transactions
	5.10 Connection Management in Web and Enterprise Applications
Chapter 6. The Date and Time API
	6.1 The Time Line
	6.2 Local Dates
	6.3 Date Adjusters
	6.4 Local Time
	6.5 Zoned Time
	6.6 Formatting and Parsing
	6.7 Interoperating with Legacy Code
Chapter 7. Internationalization
	7.1 Locales
	7.2 Number Formats
	7.3 Date and Time
	7.4 Collation and Normalization
	7.5 Message Formatting
	7.6 Text Input and Output
	7.7 Resource Bundles
	7.8 A Complete Example
Chapter 8. Scripting, Compiling, and Annotation Processing
	8.1 Scripting for the Java Platform
	8.2 The Compiler API
	8.3 Using Annotations
	8.4 Annotation Syntax
	8.5 Standard Annotations
	8.6 Source-Level Annotation Processing
	8.7 Bytecode Engineering
Chapter 9. The Java Platform Module System
	9.1 The Module Concept
	9.2 Naming Modules
	9.3 The Modular “Hello, World!” Program
	9.4 Requiring Modules
	9.5 Exporting Packages
	9.6 Modular JARs
	9.7 Modules and Reflective Access
	9.8 Automatic Modules
	9.9 The Unnamed Module
	9.10 Command-Line Flags for Migration
	9.11 Transitive and Static Requirements
	9.12 Qualified Exporting and Opening
	9.13 Service Loading
	9.14 Tools for Working with Modules
Chapter 10. Security
	10.1 Class Loaders
	10.2 User Authentication
	10.3 Digital Signatures
	10.4 Encryption
Chapter 11. Advanced Swing and Graphics
	11.1 Tables
	11.2 Trees
	11.3 Advanced AWT
	11.4 Raster Images
	11.5 Printing
Chapter 12. Native Methods
	12.1 Calling a C Function from a Java Program
	12.2 Numeric Parameters and Return Values
	12.3 String Parameters
	12.4 Accessing Fields
	12.5 Encoding Signatures
	12.6 Calling Java Methods
	12.7 Accessing Array Elements
	12.8 Handling Errors
	12.9 Using the Invocation API
	12.10 A Complete Example: Accessing the Windows Registry
	12.11 Foreign Functions: A Glimpse into the Future
Index
Code Snippets
Contents
Introduction
Epstein's Black Book Unredacted!
	A
	B
	C
	D
	E
	F
	G
	H
	I-J
	K
	L
	M
	N
	O
	P
	Q
	R
	S
	T
	U-V
	W
	Y
	Z
65th St NYC
America
Brazil/Entertainment/Finance
France
Hotels
Island
Israel/Italy
J E Biz Assoc?
71st St. NYC
Kenya/Kinnerton
Medical
PB
Rugs/Security
Switzerland/Travel
Ranch/RM
Who's Who Of Epstein's Black Book | spidercatweb.blog
	A
	B
	C
	D
	E
	F
	G
	H
	I-J
	K
	L
	M
	N
	O-P
	Q-R
	S
	T
	U-V
	W
	Y
	Z, Etc. Ghislaine
Jeffrey Epstein_ Complete FLIGHT LOGS of the Lolita Express and you should see the names! _ SocialMediaMorning.com
Copyright
Title Page
Dedication
Contents
Chapter 1: ‘I’m thinking’ – Oh, but are you?
Chapter 2: Renegade perception
Chapter 3: The Pushbacker sting
Chapter 4: ‘Covid’: The calculated catastrophe
Chapter 5: There is no ‘virus’
Chapter 6: Sequence of deceit
Chapter 7: War on your mind
Chapter 8: ‘Reframing’ insanity
Chapter 9: We must have it? So what is it?
Chapter 10: Human 2.0
Chapter 11: Who controls the Cult?
Chapter 12: Escaping Wetiko
Postscript
Appendix: Cowan-Kaufman-Morell Statement on Virus Isolation
Bibliography
Index
Cover
Title Page
Copyright Page
Contents
Foreword
Preface
Acknowledgments
1 Introduction
2 Creating and Destroying Objects
	Item 1: Consider static factory methods instead of constructors
	Item 2: Consider a builder when faced with many constructor parameters
	Item 3: Enforce the singleton property with a private constructor or an enum type
	Item 4: Enforce noninstantiability with a private constructor
	Item 5: Prefer dependency injection to hardwiring resources
	Item 6: Avoid creating unnecessary objects
	Item 7: Eliminate obsolete object references
	Item 8: Avoid finalizers and cleaners
	Item 9: Prefer try-with-resources to try-finally
3 Methods Common to All Objects
	Item 10: Obey the general contract when overriding equals
	Item 11: Always override hashCode when you override equals
	Item 12: Always override toString
	Item 13: Override clone judiciously
	Item 14: Consider implementing Comparable
4 Classes and Interfaces
	Item 15: Minimize the accessibility of classes and members
	Item 16: In public classes, use accessor methods, not public fields
	Item 17: Minimize mutability
	Item 18: Favor composition over inheritance
	Item 19: Design and document for inheritance or else prohibit it
	Item 20: Prefer interfaces to abstract classes
	Item 21: Design interfaces for posterity
	Item 22: Use interfaces only to define types
	Item 23: Prefer class hierarchies to tagged classes
	Item 24: Favor static member classes over nonstatic
	Item 25: Limit source files to a single top-level class
5 Generics
	Item 26: Don’t use raw types
	Item 27: Eliminate unchecked warnings
	Item 28: Prefer lists to arrays
	Item 29: Favor generic types
	Item 30: Favor generic methods
	Item 31: Use bounded wildcards to increase API flexibility
	Item 32: Combine generics and varargs judiciously
	Item 33: Consider typesafe heterogeneous containers
6 Enums and Annotations
	Item 34: Use enums instead of int constants
	Item 35: Use instance fields instead of ordinals
	Item 36: Use EnumSet instead of bit fields
	Item 37: Use EnumMap instead of ordinal indexing
	Item 38: Emulate extensible enums with interfaces
	Item 39: Prefer annotations to naming patterns
	Item 40: Consistently use the Override annotation
	Item 41: Use marker interfaces to define types
7 Lambdas and Streams
	Item 42: Prefer lambdas to anonymous classes
	Item 43: Prefer method references to lambdas
	Item 44: Favor the use of standard functional interfaces
	Item 45: Use streams judiciously
	Item 46: Prefer side-effect-free functions in streams
	Item 47: Prefer Collection to Stream as a return type
	Item 48: Use caution when making streams parallel
8 Methods
	Item 49: Check parameters for validity
	Item 50: Make defensive copies when needed
	Item 51: Design method signatures carefully
	Item 52: Use overloading judiciously
	Item 53: Use varargs judiciously
	Item 54: Return empty collections or arrays, not nulls
	Item 55: Return optionals judiciously
	Item 56: Write doc comments for all exposed API elements
9 General Programming
	Item 57: Minimize the scope of local variables
	Item 58: Prefer for-each loops to traditional for loops
	Item 59: Know and use the libraries
	Item 60: Avoid float and double if exact answers are required
	Item 61: Prefer primitive types to boxed primitives
	Item 62: Avoid strings where other types are more appropriate
	Item 63: Beware the performance of string concatenation
	Item 64: Refer to objects by their interfaces
	Item 65: Prefer interfaces to reflection
	Item 66: Use native methods judiciously
	Item 67: Optimize judiciously
	Item 68: Adhere to generally accepted naming conventions
10 Exceptions
	Item 69: Use exceptions only for exceptional conditions
	Item 70: Use checked exceptions for recoverable conditions and runtime exceptions for programming errors
	Item 71: Avoid unnecessary use of checked exceptions
	Item 72: Favor the use of standard exceptions
	Item 73: Throw exceptions appropriate to the abstraction
	Item 74: Document all exceptions thrown by each method
	Item 75: Include failure-capture information in detail messages
	Item 76: Strive for failure atomicity
	Item 77: Don’t ignore exceptions
11 Concurrency
	Item 78: Synchronize access to shared mutable data
	Item 79: Avoid excessive synchronization
	Item 80: Prefer executors, tasks, and streams to threads
	Item 81: Prefer concurrency utilities to wait and notify
	Item 82: Document thread safety
	Item 83: Use lazy initialization judiciously
	Item 84: Don’t depend on the thread scheduler
12 Serialization
	Item 85: Prefer alternatives to Java serialization
	Item 86: Implement Serializable with great caution
	Item 87: Consider using a custom serialized form
	Item 88: Write readObject methods defensively
	Item 89: For instance control, prefer enum types to readResolve
	Item 90: Consider serialization proxies instead of serialized instances
Appendix: Items Corresponding to Second Edition
References
Index
	A
	B
	C
	D
	E
	F
	G
	H
	I
	J
	K
	L
	M
	N
	O
	P
	Q
	R
	S
	T
	U
	V
	W
	Z