Java 1.5 Tiger A Developers Notebook [Electronic resources] نسخه متنی

• Table of Contents

• Index

• Reviews

• Examples

• Reader Reviews

• Errata

• Academic

Java 1.5 Tiger: A Developer''''s Notebook

By
David Flanagan, Brett McLaughlin

Publisher: O''''Reilly

Pub Date: June 2004

ISBN: 0-596-00738-8

Pages: 200

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