Java 1.5 Tiger, A Developer s Notebook, Flanagan D., McLaughlin B., 2004

Java 1.5 Tiger, A Developer's Notebook, Flanagan D., McLaughlin B., 2004.

   Java 5.0, code-named "Tiger", promises to be the mostsignificant new version of Java since the introduction of the language. With over a hundred substantial changes to the core language, as well as numerous library and API additions, developers have a variety of new features, facilities, and techniques available.
   But with so many changes, where do you start? You could read through the lengthy, often boring language specification; you could wait for the latest 500 page tome on concepts and theory; you could even play around with the new JDK, hoping you figure things out—or you can get straight to work with Java 5.0 Tiger: A Developer's Notebook.
This no-nonsense, down-and-dirty guide by bestselling Java authors Brett McLaughlin and David Flanagan skips all the boring prose and lecture, and jumps right into Tiger. You'll have a handle on the important new features of the language by the end of the first chapter, and be neck-deep in code before you hit the halfway point. Using the task-oriented format of this new series, you'll get complete practical coverage of generics, learn how boxing and unboxing affects your type conversions, understand the power of varargs, learn how to write enumerated types and annotations, master Java's new formatting methods and the for/in loop, and even get a grip on concurrency in the JVM.
Copyright
The Developer's Notebook Series
Notebooks Are...
Notebooks Aren't...
Organization
Preface
Organization
How This Book Was Written
About the Examples
Conventions Used in This Book
How to Contact Us
Acknowledgments from Brett
Acknowledgments from David
Chapter 1. What's New?
Section 1.1. Working with Arrays
Section 1.2. Using Queues
Section 1.3. Ordering Queues Using Comparators
Section 1.4. Overriding Return Types
Section 1.5. Taking Advantage of Better Unicode
Section 1.6. Adding StringBuilder to the Mix
Chapter 2. Generics
Section 2.1. Using Type-Safe Lists
Section 2.2. Using Type-Safe Maps
Section 2.3. Iterating Over Parameterized Types
Section 2.4. Accepting Parameterized Types as Arguments
Section 2.5. Returning Parameterized Types
Section 2.6. Using Parameterized Types as Type Parameters
Section 2.7. Checking for Lint
Section 2.8. Generics and Type Conversions
Section 2.9. Using Type Wildcards
Section 2.10. Writing Generic Types
Section 2.11. Restricting Type Parameters
Chapter 3. Enumerated Types
Section 3.1. Creating an Enum
Section 3.2. Declaring Enums Inline
Section 3.3. Iterating Over Enums
Section 3.4. Switching on Enums
Section 3.5. Maps of Enums
Section 3.6. Sets of Enums
Section 3.7. Adding Methods to an Enum
Section 3.8. Implementing Interfaces with Enums
Section 3.9. Value-Specific Class Bodies
Section 3.10. Manually Defining an Enum
Section 3.11. Extending an Enum
Chapter 4. Autoboxing and Unboxing
Section 4.1. Converting Primitives to Wrapper Types
Section 4.2. Converting Wrapper Types to Primitives
Section 4.3. Incrementing and Decrementing Wrapper Types
Section 4.4. Boolean Versus boolean
Section 4.5. Conditionals and Unboxing
Section 4.6. Control Statements and Unboxing
Section 4.7. Method Overload Resolution
Chapter 5. varargs
Section 5.1. Creating a Variable-Length Argument List
Section 5.2. Iterating Over Variable-Length Argument Lists
Section 5.3. Allowing Zero-Length Argument Lists
Section 5.4. Specify Object Arguments Over Primitives
Section 5.5. Avoiding Automatic Array Conversion
Chapter 6. Annotations
Section 6.1. Using Standard Annotation Types
Section 6.2. Annotating an Overriding Method
Section 6.3. Annotating a Deprecated Method
Section 6.4. Suppressing Warnings
Section 6.5. Creating Custom Annotation Types
Section 6.6. Annotating Annotations
Section 6.7. Defining an Annotation Type's Target
Section 6.8. Setting the Retention of an Annotation Type
Section 6.9. Documenting Annotation Types
Section 6.10. Setting Up Inheritance in Annotations
Section 6.11. Reflecting on Annotations
Chapter 7. The for/in Statement
Section 7.1. Ditching Iterators
Section 7.2. Iterating over Arrays
Section 7.3. Iterating over Collections
Section 7.4. Avoiding Unnecessary Typecasts
Section 7.5. Making Your Classes Work with for/in
Section 7.6. Determining List Position and Variable Value
Section 7.7. Removing List Items in a for/in Loop
Chapter 8. Static Imports
Section 8.1. Importing Static Members
Section 8.2. Using Wildcards in Static Imports
Section 8.3. Importing Enumerated Type Values
Section 8.4. Importing Multiple Members with the Same Name
Section 8.5. Shadowing Static Imports
Chapter 9. Formatting
Section 9.1. Creating a Formatter
Section 9.2. Writing Formatted Output
Section 9.3. Using the format( ) Convenience Method
Section 9.4. Using the printf( ) Convenience Method
Chapter 10. Threading
Section 10.1. Handling Uncaught Exceptions in Threads
Section 10.2. Using Thread-Safe Collections
Section 10.3. Using Blocking Queues
Section 10.4. Specifying Timeouts for Blocking
Section 10.5. Separating Thread Logic from Execution Logic
Section 10.6. Using Executor as a Service
Section 10.7. Using Callable Objects
Section 10.8. Executing Tasks Without an ExecutorService
Section 10.9. Scheduling Tasks
Section 10.10. Advanced Synchronizing
Section 10.11. Using Atomic Types
Section 10.12. Locking Versus Synchronization
Colophon
Index