This book does a good job of getting a reader well versed in Java 1.4 up to speed with Java 1.5's (Tiger's) new features. As noted, I believe this book does a better job of doing this over Herbert Schildt's book (Java 2 v5.0 (Tiger) New Features).

Both books hit the main areas most people are concerned about: generics, enums, annotations, enhanced for loop, autoboxing and var args. However, I felt the O'Reilly book did a more in-depth job of describing the features with more concise explanations and examples. For example, the section on Enums in the O'Reilly book also covers EnumMap and EnumSet whereas the Schildt book does not. Both books also cover some of the lesser known enhancements such as static imports, updated Unicode support and the new Formatter class.

Each book covers some minor enhancements the other does not. Schildt: Scanner class, Integer enhancements. O'Reilly: Queue classes. The O'Reilly book does cover one big area that Schildt's does not - threading / concurrency enhancements. Though this area is not covered as completely as the other features, it is a good overview nonetheless. Any good discussion of these issues would warrant a book of its own and perhaps that's why Schildt left it out of his book. However, it was nice to see some coverage in the O'Reilly book.

I guess my only complaint with the O'Reilly book is the "notebook" style itself with the gridlines and "hand written" notes in the margins. It does require some getting used to.

This book delivers most of what it promises to, which is a good introduction to the latest and greatest features of Java 1.5 Tiger. Considering the extent of changes Sun introduced in the new version, I think the authors did a decent job explaining them. If you are new to 1.5 version though, you would probably need to read another book that explains the concepts in greater detail.

My only complaint is with the "Threading" chapter which was full of of API methods instead of letting the users know the concepts behind the changes. Looked like the authors were in a hurry to get the book finished and the "Threading" chapter got affected.

Overall, it is a good read.

There's nothing in this book that you couldn't find on Sun's website, but it's a good quick reference book.

This is a great book. If you know Java 4 and you want to upgrade your knowledge, this book is short-and-sweet -- only 170 pages. It tells you quickly what is new in Java 5 so that you can make the transition from Java 4 prograamming to Java 5 programming.

First off, i sincerely appreciate O'Reilly on their innovative idea of a notebook series. This series is targetted towards busy developers who dont find the time to crunch through big fat books and learn about every grain of sand; rather they would spend less time and learn what is absolutely required. This is certainly a welcome concept.

That said, this book is about the new additions that sun incroporated into java 5 (Tiger). Yes, there are so many additions that it requires a book in itself. The author covers all the significant additions like Generics, Enums, Autoboxing, Varargs, Annotations, Enhanced For-Loop, Static Imports, printf and Threading. Isnt that a mouthful? Yet, he covers them in under 200 pages. That in itself is an achievement. Also, the conversational tone and the humour with which the author writes makes the text very interesting.

Now, for the bad news. This book is edited pretty poorly. There are a lot of typos both in the text and code. I understand that, this book is conceptualized saying that it is a scribbling of an alpha geek who takes down notes as he researches new technologies. But, that doesnt mean that we get to read the same scribbling without even getting edited, though we pay for it.

More than the typos, the author establishes certain technical claims, which are both wrong and misleadging. For example, the author claims that it is IMPOSSIBLE to use the enhanced-for-loop for generating a comma-seperated string from a list of strings, where the resulting comma-seperated string doesnt end with a comma, so as to display formateed output. The author justifies this by saying that a developer doesnt have access to the counter variable in the enhanced-for-loop. Though i agree that we dont have access to the count variable, the use-case is ofcourse possible. This piece of code can be used to achieve what the author claims IMPOSSIBLE.

import java.util.List;
import java.util.ArrayList;

public class CommaString {
public static void main(String[] args) {
List numList = new ArrayList();
numList.add("1"); numList.add("2"); numList.add("3");

String numStr="";
for(String num: numList)
numStr = numStr.equals("") ? (numStr+num) : (numStr+", "+ num);

System.out.println(numStr);
}
}

This may not be the most efficient implementation, but, it atleast proves that what author claims as impossible is rather possible. There were some statements like this in the threading chapter as well, where the author compares synchronized keyword and lock. So, beware not to always go with author's opinions, but ofcourse, the technical content can be trusted.

In the end, i would say that this book achieved its goal by neatly summarizing all the significant improvements/additions in tiger and we sure can learn every feature from this book. There are some issues, but it will not affect the overall value of the book as long as you dont overlook them.