Java 1.5 Tiger: A Developer's Notebook

Description:

Java 1.5, 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 1.5 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 1.5 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:

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