Amazing Books
Temporary Blank

Monday, September 27, 2010

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



This no-nonsense, guide by bestselling Java authors Brett McLaughlin and David Flanagan jumps right into Tiger. Using the task-oriented format of this new series, you'll get complete practical coverage of generics, boxing and unboxing, varargs, enums, annotations, formatting, the for/in loop, concurrency, and more.

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 Impots
Section 8.1. Impoting Static Members
Section 8.2. Using Wildcards in Static Impots
Section 8.3. Impoting Enumerated Type Values
Section 8.4. Impoting Multiple Members with the Same Name
Section 8.5. Shadowing Static Impors
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

Download
Another Java Books

No comments:

Post a Comment

Related Posts with Thumbnails
There was an error in this gadget

Put Your Ads Here!
There was an error in this gadget