Java 5.0 Tiger: A Developer's Notebook

Tell a friend

Java 5.0 Tiger: A Developer's Notebook By David Flanagan, Brett McLaughlin
June 2004
Pages: 200

| Table of Contents | Index | Sample Chapter | Colophon

Chapter 1 What's New?
1. Working with Arrays
2. Using Queues
3. Ordering Queues Using Comparators
4. Overriding Return Types
5. Taking Advantage of Better Unicode
6. Adding StringBuilder to the Mix
Chapter 2 Generics
1. Using Type-Safe Lists
2. Using Type-Safe Maps
3. Iterating Over Parameterized Types
4. Accepting Parameterized Types as Arguments
5. Returning Parameterized Types
6. Using Parameterized Types as Type Parameters
7. Checking for Lint
8. Generics and Type Conversions
9. Using Type Wildcards
10. Writing Generic Types
11. Restricting Type Parameters
Chapter 3 Enumerated Types
1. Creating an Enum
2. Declaring Enums Inline
3. Iterating Over Enums
4. Switching on Enums
5. Maps of Enums
6. Sets of Enums
7. Adding Methods to an Enum
8. Implementing Interfaces with Enums
9. Value-Specific Class Bodies
10. Manually Defining an Enum
11. Extending an Enum
Chapter 4 Autoboxing and Unboxing
1. Converting Primitives to Wrapper Types
2. Converting Wrapper Types to Primitives
3. Incrementing and Decrementing Wrapper Types
4. Boolean Versus boolean
5. Conditionals and Unboxing
6. Control Statements and Unboxing
7. Method Overload Resolution
Chapter 5 varargs
1. Creating a Variable-Length Argument List
2. Iterating Over Variable-Length Argument Lists
3. Allowing Zero-Length Argument Lists
4. Specify Object Arguments Over Primitives
5. Avoiding Automatic Array Conversion
Chapter 6 Annotations
1. Using Standard Annotation Types
2. Annotating an Overriding Method
3. Annotating a Deprecated Method
4. Suppressing Warnings
5. Creating Custom Annotation Types
6. Annotating Annotations
7. Defining an Annotation Type's Target
8. Setting the Retention of an Annotation Type
9. Documenting Annotation Types
10. Setting Up Inheritance in Annotations
11. Reflecting on Annotations
Chapter 7 The for/in Statement
1. Ditching Iterators
2. Iterating over Arrays
3. Iterating over Collections
4. Avoiding Unnecessary Typecasts
5. Making Your Classes Work with for/in
6. Determining List Position and Variable Value
7. Removing List Items in a for/in Loop
Chapter 8 Static Imports
1. Importing Static Members
2. Using Wildcards in Static Imports
3. Importing Enumerated Type Values
4. Importing Multiple Members with the Same Name
5. Shadowing Static Imports
Chapter 9 Formatting
1. Creating a Formatter
2. Writing Formatted Output
3. Using the format( ) Convenience Method
4. Using the printf( ) Convenience Method
Chapter 10 Threading
1. Handling Uncaught Exceptions in Threads
2. Using Thread-Safe Collections
3. Using Blocking Queues
4. Specifying Timeouts for Blocking
5. Separating Thread Logic from Execution Logic
6. Using Executor as a Service
7. Using Callable Objects
8. Executing Tasks Without an ExecutorService
9. Scheduling Tasks
10. Advanced Synchronizing
11. Using Atomic Types
12. Locking Versus Synchronization

Colophon

Return to Java 5.0 Tiger: A Developer's Notebook

Table of Contents

Chapter 1 What's New?

Working with Arrays

Using Queues

Ordering Queues Using Comparators

Overriding Return Types

Taking Advantage of Better Unicode

Adding StringBuilder to the Mix

Chapter 2 Generics

Using Type-Safe Lists

Using Type-Safe Maps

Iterating Over Parameterized Types

Accepting Parameterized Types as Arguments

Returning Parameterized Types

Using Parameterized Types as Type Parameters

Checking for Lint

Generics and Type Conversions

Using Type Wildcards

Writing Generic Types

Restricting Type Parameters

Chapter 3 Enumerated Types

Creating an Enum

Declaring Enums Inline

Iterating Over Enums

Switching on Enums

Maps of Enums

Sets of Enums

Adding Methods to an Enum

Implementing Interfaces with Enums

Value-Specific Class Bodies

Manually Defining an Enum

Extending an Enum

Chapter 4 Autoboxing and Unboxing

Converting Primitives to Wrapper Types

Converting Wrapper Types to Primitives

Incrementing and Decrementing Wrapper Types

Boolean Versus boolean

Conditionals and Unboxing

Control Statements and Unboxing

Method Overload Resolution

Chapter 5 varargs

Creating a Variable-Length Argument List

Iterating Over Variable-Length Argument Lists

Allowing Zero-Length Argument Lists

Specify Object Arguments Over Primitives

Avoiding Automatic Array Conversion

Chapter 6 Annotations

Using Standard Annotation Types

Annotating an Overriding Method

Annotating a Deprecated Method

Suppressing Warnings

Creating Custom Annotation Types

Annotating Annotations

Defining an Annotation Type's Target

Setting the Retention of an Annotation Type

Documenting Annotation Types

Setting Up Inheritance in Annotations

Reflecting on Annotations

Chapter 7 The for/in Statement

Ditching Iterators

Iterating over Arrays

Iterating over Collections

Avoiding Unnecessary Typecasts

Making Your Classes Work with for/in

Determining List Position and Variable Value

Removing List Items in a for/in Loop

Chapter 8 Static Imports

Importing Static Members

Using Wildcards in Static Imports

Importing Enumerated Type Values

Importing Multiple Members with the Same Name

Shadowing Static Imports

Chapter 9 Formatting

Creating a Formatter

Writing Formatted Output

Using the format( ) Convenience Method

Using the printf( ) Convenience Method

Chapter 10 Threading

Handling Uncaught Exceptions in Threads

Using Thread-Safe Collections