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 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.

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!

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!

This is my first purchase in the Developer's Notebook series, and I was pleasantly surprised. The text is concise and easy to read. And, the brevity of the book (less than 200 pages) made it one of the few technical books I read cover to cover. I read it sort of like a novel (I'm not that into running the examples in code), and for most if it, I ate it all up. It enabled me to begin using JDK 5.0 features quickly one of my current projects, and it's useful when I've forgotten a bit of syntax.

On the downside, I'm usually interested in the "why" and "how", even if it's not as important as the "what". So, often I found myself wanting to know more, and in some cases I thought the authors excluded some information that really should have been there. Granted, this may be more of an artifact of the series itself than this particular book.

Many of the examples in this book are shared in O'Reilly's Java in a Nutshell, and this book always points that out. After a while, I began to wonder why they couldn't come up with more examples that are unique for this book. I also began to think that they were trying to promote Java in a Nutshell a bit too much, and that in some ways they were sort of cheating by duplicating material in two different formats. Since this short book is still relatively expensive, I found the duplication of material somewhat annoying.

Overall, I'm very happy with this book, though. Ultimately, I might still buy a more complete reference, but at least now I know enough to get started!

Though it probably was a hit in June 2004, I would NOT recommend buying this book now. It contains some valuable information for serious developers and is easy and fun to read indeed, but:

1. Too many typos in the text. One essential section about threading is even completely lost, substituted by the text from another section due to misprint, which makes the whole chapter hard to understand. Looks like nobody at O'Reilly got a chance to read the book and look up for errors before it went to print. If somebody did, I would fire that person right away as incompetent.

2. The coverage of the material is far from completeness. If you want to just grasp new Java 5 features, go for free to
http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html.
In particular, an excellent free article at
http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf
contains 5 times more information about generics, invaluable for those who really want to understand what's going on, and why, and how to work with it.

3. Brett took a great effort to make this quite complex material easy to read, probably trying to widen the audience, but I personally prefer the style of the "Java in a Nutshell" tutorials, as twice more informative per page of text.

So now, in 2005, I would either wait for a new corrected and extended edition of this book, or try to find another one. Still four stars, just in comparison to other books on the topic.

This book will get far down the road of understanding the new features in Java 5.0. Unfortunately, there are typos and, worse yet, an entire section of text that randonly appears in another chapter's section later in the book. Very strange. All in all, though, you will learn a great deal from this book.

This book has a unique layout and presentation. It's not a comic book type new wave layout you see in text books today but a notebook that's straight to the point. The book is only for the experienced Java programmer that puts together all the new language changes. Instead of reading all those articles on new Java 1.5 features, just read this single source collection. It's a fast read detailing the language changes, how to use it, and why in a very orderly manner. Only the last chapter was out of place that covers changes in Thread programming which is not exactly Java language change but it was interesting to know for follow-up. Many speak of the new Java features of printf, autoboxing, etc., but there is a lot more and some subtle changes that you need to know. This book covers everything.

The foreword to this new O'Reilly series explains that a "Developer's Notebook" is the raw scribbling of an "Alpha Geek" as he or she examines some exciting new technology. That pretty much describes "Java 1.5 Tiger." It's raw, it's scribbling, and it's exciting nonetheless.

At a slim 177 pages, this is one of the shorter general Java books you're ever likely to see. There isn't a lot of fat between these covers. Over the faint blue graph-paper lines and the cute faux coffee stains, the concise text covers just the biggest new features in JDK 1.5: generics, varargs, autoboxing, annotations, printf, enumerations. Many of the plentiful code examples are sensible and give you a realistic idea of how to use a feature. Some of them, unfortunately, are rather contrived and don't make much sense.

My main brickbat for "Java 1.5 Tiger" is the very high incidence of typos, more in the text than in the code. Raw scribbling is one thing, but accuracy is important, too; a programming book demands it. My main bouquet is that I learned a lot from reading it, and honestly, you can't do much better than that.

Who: You. You already know Java. In fact, you silently snicker at most people who say they "really know Java," because they don't - not like you do.

Why: Java 1.5 is really different. Not just enums and boxing/unboxing, it has type-safe varargs (who'd've thunk it!), last-chance handlers for threads, the most comprehensive generic mechanism I'm seen, and more. You need to know what's new, and how to use it, and fast.

What: This book. It won't help the Java newbie. It's just the new features, spelled out in detail. Better yet, they're spelled out in code samples. This doesn't so much tell you what's new, it shows you.

Where: Here. Until the next generation of Java books hits the shelves, your alternatives are this and the language spec. Believe me, you don't want the language spec.

When: Now. This book will probably look old fast, once the more polished, friendly, and tutorial texts come out. It's a great quick-start on the new technology, though, and (see "who" above) you can't wait.

I hope O'Reilly keeps coming out with new titles in this series. I give it five stars now, but probably two a year from now. As I said, though, this book is for !right!now! and does a great job of what it does.

//wiredweird

This notebook series is a very good aid for the experienced developer who wants to play with some new feauture in the company of an even more experienced fellow who has done most of the research for him. Stay far from this one if you need to learn Java from scratch. (Go for one of the many excellent intro books by Ivor Horton or Cay Horstmann). Not surprisingly this book is one of the best in the series, being mostly the effort of Brett McLaughlin who, besides being a talented coder and writer is also the man behind the O'Reilly "developer notebook idea". In about 150 pages you will get plenty of working examples and clear, concise explanations on the new features of "Tiger": generics (templates), varargs, annotations, autoboxing etc .. If you are a serious Java developer you cannot miss on these new features, and have no excuse for doing it since now you can bridge this gap with just a few hours of reading on a train. And if you are an old school C coder who grudgingly had to pass to Java for "marketing reasons".. I have great news for you.. believe it or not, we got printf back! ;)

Having read this book I'm itching to use the new features in Tiger. I found it well written, with generally clear examples, and a lot of information in a short book. It's not the definitive reference to Java 1.5, but then I probably wouldn't have made it all the way through if it was.

The reason I didn't give it 5 stars is that there were a few cases where I would have liked some more information about using the new features in an Enterprise system. In particular there are these two points that I'm still looking for answers to:

1) When discussing Enums there's no discussion of using them Remotely (via RMI). Can emums still be compared using == if they have come from a remote client? If not, can the new form of switch be used?

2) Comparison of the new Formatter to MessageFormat. In particular the performance of the new Formatter (because MessageFormat is slow).

Perhaps I need to write myself some tests, because I was frustrated that I couldn't find the answers to these questions on the web.

Another thing that I think could have been covered is the JVM changes introduced in 1.5 - the implications of class data sharing between virtual machines and the changes to garbage collection. Admittedly not as interesting as the language changes, but if you're going to use the new features you're going to have to use the new JVM.

Java 1.5 Tiger Developer's Notebook is a great introduction to the new features of Java 1.5 (aka Tiger). It has numerous smallish examples and a conversational tone (almost too conversational at times). It covers all the major additions to the language. Possibly the only thing missing was a discussion of the reason for the "syntactic sugar" that spawned these new features.

Regardless of whether you are a fan of Java 1.5's new features, you'll find this Notebook to be a great guide.

For what it is this book is focused and great. So it's important to understand what this book is and who it's for. This is not, with it's thin 170 page frame, a book that covers all of the Java language syntax. It is very specific to the features of 1.5. It covers generics, autoboxing, enums, varargs, and more. All of the new features added to make Java compete with C# are covered here in a terse and aggressive form. This book is for people who know Java well and want to learn more about 1.5.

I recommend this book for Java professionals and architects who understand the new features conceptually but want details on how they work directly in the code. This is not a book for someone who just wants to start with Java. For that I recommend O'Reilly's Learning Java or Java in a Nutshell.

"Java 1.5 Tiger - A Developer's Notebook" has all the information and quality we have come to expect from O'Reilly. However, the developer's notebook series has a very different style than the animal books. The book was a true page-turner and I read all 171 pages in two days.

This book really looks like a notebook complete with notes in the margins, graph paper and coffee cup stains! There is also plenty of room in the margins for the reader to add notes. This book is informative, useful and looks really cool!

A guru narrates the book. He tells you about Java 1.5 and answers your questions. Each chapter discusses several labs in a task/how to I do that?/what about ... format. It is like the author walks you through doing the labs. It really does read like a conversation. As the authors put it - "All lab, no lecture."

The code examples begin on page two and are prevalent throughout the book. The authors give warnings about common pitfalls and tasks that you cannot do - just like you would expect a guru to do. The authors also give opinions and recommendations.

The book assumes a working knowledge of java 1.4 (or earlier.) This is especially important in the conncurrency section. There is excellent cross-referencing so the chapters and tasks can be read in almost any order. This was an amazing book!

I got my first experience with a new O'Reilly series... The Developer's Notebook. This notebook is the Java 1.5 Tiger Developer's Notebook by Brett McLaughlin and David Flanagan. This is a great book and a nice concept sure to become a favorite with developers.

The chapter breakdown: What's New?; Generics; Enumerated Types; Autoboxing and Unboxing; varargs; Annotations; The for/in Statement; Static Imports; Formatting; Threading; Index

As you can see, this is not a Java tutorial or a broad overview of the Java language. It is a practical focus on the new features in Java 1.5 (codenamed Tiger), and it skips the fluff and takes you right into hands-on stuff. The concept of a "developer's notebook" is that it's a place to record observations and take notes. It goes to the meat of the subject. The book is printed on paper that has a graphed background, and there are "handwritten" notes in the margin to point out additional facts. Conversational in tone, you are walked through how each of the new features work as well as what you would use them for. Each chapter has a number of "How do I do that?", "What just happened?", and "What about..." paragraphs that quickly guide you into understanding each new feature.

For instance, the for/in language feature is covered nicely. The authors show you how it is a nice replacement for the Iterator class. But rather than stop there, they tell you what the pros and cons of the feature are.... When you'd want to use it instead of an Iterator, and when an Iterator is the only way to get what you're looking for.

I liked this book a lot. I'm looking forward to more books in the Developer's Notebook series. It might end up being the best series for getting into a subject quickly without wading through a lot of fluff or hard-to-follow jargon.

Java 1.5 has started to emerge into general usage. But most of us Java programmers are still safely ensconced in 1.4. Not a few are undoubtedly wondering what the big deal is about 1.5. If you're like me, you are probably quite satisfied with 1.4.

Well this book quickly attempts to change that opinion. It hits all the new stuff, with simple descriptions and example code. Like autoboxing. Nothing deep about this, to say the least. But it really eliminates a lot of visual clutter in your source code, when you have to go between a primitive and its wrapper type. It is the analog of how you can do (eg) System.out.println(' t='+t+' d='+d); where t and d can be any primitive types, and the jvm figures out the printing for you. You don't have to specifically describe the output format for each type, as you have to in C. The wonder about autoboxing (and its inverse) is that it was not introduced way earlier. Well, anyway, you have it now.

Long time C programmers will also welcome varargs, which are variable argument lists. Ever since Java came out in 1996, many asked for this ability. This push has gone on for years. Finally, they scored and we have varargs.

Other 1.5 changes are covered. But the above should be enough to give you a flavour of what the book offers.