Full Description
Java 5.0, code-named 'Tiger', promises to be the most significant 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.
Light on theory and long on practical application, Java 5.0 Tiger: A Developer's Notebook allows you to cut to the chase, getting straight to work with Tiger's new features. The new Developer's Notebooks series from O'Reilly covers important new tools for software developers. Emphasizing example over explanation and practice over theory, they focus on learning by doing--you'll get the goods straight from the masters, in an informal and code-intensive style that suits developers. If you've been curious about Tiger, but haven't known where to start, this no-fluff, lab-style guide is the solution.
Table of Contents
The Developer's Notebook Series
Preface
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
Using Blocking Queues
Specifying Timeouts for Blocking
Separating Thread Logic from Execution Logic
Using Executor as a Service
Using Callable Objects
Executing Tasks Without an ExecutorService
Scheduling Tasks
Advanced Synchronizing
Using Atomic Types
Locking Versus Synchronization
Index
