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.

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.

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.

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.

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.

This book delivers on what it promises - quick and dirty introductions to the new features of Tiger. It does a great job of getting one familiar with all of the new features, though, as noted by other reviewers, it is not intended to be an in depth reference. The chapters on generics and concurrency could certainly be deeper, but the book provides a good grounding in the basics, opens the door to more complete study, and provides enough sample code to get one writing code.

This book was never intended to teach newbies the Java language version 5.0. Its purpose is to teach those features of Java 5.0 that are completely new to the language to veteran Java programmers. This is very helpful to those of us who already know Java and do not want to invest in an $80 1200 page tome that will teach the entire Java language to us once again. The book consists of 10 chapters:
1. What's New
2. Generics - Generics provides a way for you to communicate the object type of a collection to the compiler, so that it can be checked.
3. Enumerated Types - Java gets linguistic support for enumerated types beyond the int Enum pattern. In their simplest form, these enums look just like their C, C++, and C# counterparts, but they are far more powerful.
4. Autoboxing and Unboxing- This pertains to a more straightforward way of inserting and removing objects from a collection using their true object notation.
5. varargs- Previously, a method that took an arbitrary number of values required you to create an array and put the values into the array prior to invoking the method. This new feature automates and hides the process.
6. Annotations -A metadata facility that permits you to define and use your own annotation types. Annotations do not directly affect program semantics, but they do affect the way programs are treated by tools and libraries.
7. The for/in Statement - often called either "enhanced for" or "foreach" is largely a convenience feature in Java 5.0.
8. Static Imports - The static import construct allows unqualified access to static members without inheriting from the type containing the static members.
9. Formatting - An interpreter for printf-style format strings has been added.
10. Threading - There have some been some major advances to the design of threading in Java.
Each chapter explains the new concept that has been introduced to the language and shows the reader how to incorporate that feature by showing actual code. As other reviewers have pointed out, there are a moderate amount of typos in this book. Some are just cases of spelling errors where it is obvious what was really meant, but some are in the code itself and impede understanding of the concepts being taught. Overall, though, I am a fan of the Developer's notebook series and I think that it works well for showcasing Java's new features. I just wish more care would have gone into the editing process.

I found the book shallow. Probably Notebook series is meant to be that way, a quick overview of a subject. What a programmer needs is developing intuition in the tool it uses. If you need a quick tour of Tiger this book is good but, http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html, I beleive is good enough for this purpose. Especially the tutorial on generics far beyond better than what this book covers. You can find it at http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

This is a book that I refer to often when I need to look up a JDK5 programming addition. Concise and to the point. Enough said.

The treatment of Generics, Enhanced for loops, threads is enough to justify buying this book.

Anil Saldhana
Chicago Java Users Group

Concise, brief, to-the-point, hands-on, and so on. After reading this one, I already love the new Notebook series from O'Reilly. It's packed with examples, and little boring theory. Definitively written by programmers, for programmers ;)

The bad news first; Yes, there are some technical flaws in the production of the book. There's about a page worth that looks like it was exactly duplicated three pages later (very confusing - for about 30 seconds I had thought I'd lost my mind or become supernaturally prescient), and there are some missing parentheses at a couple places. But these are minor and forgivable, considering the positives!

The tone of voice and the balance of text with code is just perfect for we Java developers who get frustrated with books that either talk down to us like we're in kindergarten, or talk in that crazy "uber-guru-shorthand-speak" that leaves our eyes glazed over waiting for the explaination OF the explaination.

This book is not for the out-of-the-gate beginner who trying to learn the basics of the langauge syntax or of object-oriented concepts. But beginners should NOT FEAR this book. Once you've got the basics, the information presented in this book is immediately useful, and is by no means reserved for the expert (but is certainly required if you want to BE an expert, or work with experts).

The focus of this book is on getting intermediate and expert java developers up to speed with many of the language changes that come with the Java 5.0 release. While it dabbles a little in a few of the new classes, it is not meant as a class reference. It is meant more as a distillation of many of the key changes to the basic structure of the Java syntax. The class reference aspect is very intentionally left to thick, dry books like "In a Nutshell".

This book never gets heady with theory or philosophy, nor does it get bogged down in details. I'll admit, annotations of annotations hurt my brain a bit, and the long class/method names in the new Threading scheme made it difficult to take it all in quickly, but that's not the fault of this book's author. Indeed, even during the descriptions of things that were totally new to me, I repeatedly found myself asking "What about..." only to have THAT EXACT QUESTION asked and immediately answered in the very next paragraph. Usually when an author tries to anticipate like that, they come off as sounding schizophrenic.

This book, and its format/tone of voice is a dream come true! Now if all development texts were as easy to learn from as this one, we'd REALLY have something!

Dang good job, Brett (and David)! But please consider hiring a [better] copyeditor for future efforts - and I hope there are many!

The book covers in deep details new features of Java 5.0 .
I found very convenient the "packed" form of the book. I have no time to begin read another x-hundred pages book. So it is for those who are very busy and want to learn new features of Java Tiger. The authors of the book very nicely describe the details what is "behind" the curtain of Java compiler concerning Java generics. It gave me what I wanted and now I am also started to buy "big" book about Java 5.0 from David Flanagan when I have enough time.

I do really like this book. It is a thin book in a beautiful layout (well I came from a laboratory environment). The text is easy to follow and rich in information. It is an ideal book to come up to speed on the new features of Java 1.5, especially since now you get full 1.5 support in Eclipse. And do not worry about the typos the text, the prose is still clear. Also do not worry about the short treatment of concurrency. It is just a quick start intro and it serves this purpose well.

I bought this book and I will recommend it just if You know java very good, and what to learn just what is new on java 5.
The good thing about it is that you do not have to jump from stuff that you already know. the bad thing about it is that it can be out of the context.
I bought this book while working on a site I was building (...) and wishing to write it on java 1.5, and not 1.4. The truth - In the end I wrote it on JDK 1.5 but with any new feature of java 5.
Old habits are hard to change.
Another thing that disturbed me with the book are the headlines, which are all the same in the book, and not subject dependent.
Other than this, this book is very good, and I recommend it.

This book is for you if you have been programming with Java and want a quick intro to the latest version (code named Tiger). All new features are explained in simple language, the author is really not a long-winded type. I recommend this to all Java folks out there.

This book is part of O'Reilly's Developer's notebook series. These books are short and to the point, because the book explains the "what" and not the "how" and "why." If you want long explanations and concept diagrams this is not that type of book. This book provides examples to make the new technology work.

The authors explain all the new features added to the Java language in version 1.5. The book has ten chapters that each shows a new feature added, for example autoboxing, enumerated types, annotations, etc. Each chapter provides working example that demonstrate the new feature. Everything that is introduced has a "How do I do that?" section, which show you how to use the new feature. Because of the style of book, some explanations will not provide enough detail to help you master the subject. The chapter on threading is not enough for a developer to understand the concepts, but is enough to start using some of the java.util.concurrent classes.

This book is very good at what it is written for, to quickly get an experience developer running with the new language features. This should be treated as a starter book and other books would be needed, if a greater understanding of the subject is needed.

I found this book very interesting and I hope to continue to use
it. First, the positives. It provided a good survey of the most
important new features in Java 1.5. Some of the examples were
quite detailed and very useful, and it is good to have all the new
features collected together into one place. It will also provide
a place to quickly look up the syntax for some of the new
features, especially Generics, Enums, and Formatting.

On the downside I didn't really like the tone of the book - I got
fed up with seeing "cool" all over the place. I also don't
understand the intended audience for the book. It is too advanced
for beginning Java programmers, and yet it doesn't contain enough
detail for advanced programmers. The section on Threading was
especially lightweight. Doug Lea's Concurrency book (from which
all of the new support for multithreading in Java 1.5 is derived)
is an extremely dense and difficult book. Any attempt to try and
cover the material in a few pages is unlikely to meet with much
success. This chapter was good for advertisement: "here are some
new classes" but not much else.

In summary, this is a good overview of the new features in Java
1.5, and useful as a reference for many of the features. I would
recommend it to any intermediate Java programmer who wants to get
up to speed quickly. However, it is not intended as a reference,
so do not expect to get one!