I am a programmer, and in a programming language book, I expect to find syntactical diagrams of the language. Anyone can read those, we should not have to glean the diagram from the wordy explanation. It's fine to have all the verbiage, but head each section with the syntax diagram.
Also, this book goes into lengthy explanations of what object oriented programming is NOT, as on page 104. This is a very bad practice in teaching. Only teach what is correct, not what some novice might ignorantly think. I have gotten better fundamentals in Java free on the w3c site.

I used to like this Nutshell book, but it seems to have grown a little too big for its bridges. Maybe it's not O'Reily's fault. Maybe it has more to do with Java growing so much. But earlier versions were quick and to the point. This is now overly verbose.

This is no longer a sleek Nutshell. Its a back-breaking bomb shelter with 10ft thick walls.

I very much like this as a reference, but at this point I feel like most of the back 2/3 of the book is unnecessary bulk. The front portion, however, is excellent.

This is a great book for those Java programmers who want a rapid reference. The only drawback of this book is its weigth: the large part of the book is made of a Java reference (very similar to the official JavaDoc) that in my opinion is not so helpful, as if I need the documentation for a specific class I can browse the official documentation online.
Anyway, the first part of the book is well written and gives many examples that can help both new and experienced programmers to understand the main features of Java 5.

The book is by far the most comprehensive, plain english manual for java that exists. Great book, but anyone who see's it laughs at the title. I think it must be an intentional joke. With 1225 pages and weighing in at a hefty 1.5kg (3.3lb) it's by no means a nutshell. It's more like a bombshell. If it were ever to be divided into 3 books, I would buy it again, just so that using it wouldn't be so cumbersome.

Excellent book! Difficult to believe a "nutshell" is over 1200 pages, but that's Java.

Thank you,
Rick Rodgers

This is a great reference book has great information, all of the basics and some of the more advanced concepts. However, this is not a must have, most of the information if not all of the information in the book can be found online.

If you like your documentation/references in print then this is your java reference.

Though I work on Java for 7 years, I still do not know many basic stuff. Even I know the big picture, I may not really know the detail. I learn a lot from this book.
I strongly suggest this book to anybody working on Java, even for experienced developer. It is a great book to review and refresh. You may be surprised there are something you did not really know and actually they are very important.

I should give it 5 star, but it wasted too much paper for printing API. It waste my money and it caused more tree to be cut. So 4 star.

Highly recommended. Concentrated and well indexed information.
If you need a nutshell book for tiger, this is best one.

I teach an undergraduate course on Java, focussing on concurrency and other "advanced" features, and have found that the 5th edition of Java in a Nutshell makes an excellent textbook. It can be a little intimidating for some students at the start, especially those who prefer a wordier style with more asides and less meat, but they mostly get used to it and see the value. The initial tutorial material is fast-paced and well-suited to people who can already program, and the reference material at the back is incredibly helpful for beginners who need to browse the libraries to see what is available. Java is a big language, and this is a big book, but it's extremely useful.

This book is truly an excellent reference for Java, however, don't use it for much more than that. When I find myself needing to review old material, I have turned to this book first, for it lays out the intricacies and nit-picky details of the language in meticulous detail. The examples are few for each topic though, because there is so much to cover in a reference manual. Don't go in expecting to learn the complexities of the Java language from this book, but you will feel enriched whenever you find yourself needing to refresh your knowledge of the different means by which one can perform operations multi-dimensional arrays.

This is a great reference to have for quickly looking up information. You know, most of the stuff I look up here is already in the JavaDoc, but somehow, reading it all from a book seems to make more sense.

If you re involved in Java development you'll enjoy having this book in the desktop.

It's a reference book, don't expect to use it as bed reading, I suggest other titles as "Learning Java" from the same publisher to fill your nights.

As a reference book it's a must have.

Although this book is an in-depth reference rather than a programming manual, I think it would also be useful to those who want to get an overview of the language. The first 160 pages contain an excellent description of the Java language along with a few carefully selected code examples. The next 150 pages introduce the Java platform as well as the new Java 5.0 features. All basic API functionality is described and exemplified by short code examples. Thus by reading the first 300 pages you get a concise, yet thorough overview of Java. The matter-of-fact writing style may not be everybody's cup of tea, indeed some may find it a bit dry. On the other hand, I find it much preferable to the wordy and chatty style of so many other "introductory" computer books. At least, the author isn't wasting my time. The largest part of the book -ca. 800 pages- is taken up by detailed API documentation. The book is well organised, meticulously accurate, and authoritative. You may want to come back to it often. I certainly do. Five stars because it's really useful.

This book really is the one-stop shop for Java language information. While many complain that the page count is very high and the book is slightly heavy, this is actually a *good* thing. I love the fact that all this info is in ONE book. One book to buy, one book to carry around, one book to reference, one book to bind them...hey wait a minute!

I seriously hope Oreilly keeps updating this book with Java 6/Mustang and beyond information. Thin books are way over-rated, we need more books chock full of useful information like this one.

This book is really useful to have on hand, but it is HUGE for a nutshell book. I realize that they need every page to document the code it is just makes it hard to keep this book on the desk. Over all I think the book could have used more examples on how to make the method calls rather than showing the methods and what they do. Over all if you need a book that documents most of the java libraries this is an excellent choice, but don't expect to pick up this book if you have no programming experience and learn how to call these methods.

I use this Java book more than any other programming book I've ever had. That's probably because it's a reference book. Although all the reference material I could need is available online, I still like having the book on the desk next to me so I can look up a class or a method without playing around on the computer. I became a Sun Certified Java Programmer several years ago and although I've read many Java books before then and since then, the only book I would be hard pressed to do without is this one!

I have coded Java for many years, and I have always considered the the successive editions of the nutshell book an essential reference. Whilst this book is not suited to learning Java, it is very handy when you need to look up the concise facts. I highly recommend this book even if you have previous editions. Java 5 has some significant changes, and you will run into problems if you don't take time to understand them.

I believe it says a lot about the state of Java as a language that 1,252 pages are required to describe the language "in a nutshell." Since the second edition, this book has tripled in size. Surely this book now goes beyond the scope of what is required to teach the basics of the language.

I have very little experience with Java and I was required in an Object-oreiented Java course to come up to speed on object oriented concepts. Not only did I need to learn these concepts, I also needed to come up to speed on the basic elements of the language. This book was just what I needed. Like other O'Reilly "in a nutshell books", this one is great for a motivated learner. I would certainly like to see more graphic presentations; however, that would make the book very thick -- and heavy. Still, those of us who sit and stare at a screen all day, could benefit from the workout! Overall, a terrific book.

The "Java in a Nutshell" series probably peaked in usefulness around the second edition. The only reason it has eroded somewhat in value is:
1. The size of the language has grown to the point that key parts of the language - enterprise and foundation classes - were omitted and spun off into their own nutshell series.
2. Even the core portion of the language has grown so much that the resulting book has become quite unwieldy.
However, that being said, I would want a copy of this reference on my desk as long as up-to-date editions are in existence. You probably cannot learn Java from this book alone, but many key points on syntax and language features are concisely presented in the first part of this book along with good examples. Chapter four alone, on changes specific to Java 5, along with pertinent examples, is worth the price of admittance. The second part of the book is mainly just a listing of the javadoc, with some good notes and crossreferencing that make the information worthwhile. A good companion to this book is the latest edition of "Java Examples in a Nutshell" which contains many good illustrations of the Java programming language in action.

Java 1.5 (or 5.0, depending on whether you listen to the technical tpes or the marketing people), redefines Java - the biggest change since 1.2 (or was that 2.0?) and this book covers it all.

The author decided to make this a book that you could actually carry around with you, so he dropped most of the deprecated options, plus some of the lesser used packages (java.beans, .security.acl).

This book is important because Java, with version 5, has signiificant additions (generic types, a for/in statement, varargs, to list some of the lesser stuff). As in the previous editions, the author does a great job of providing a readable text that can benefit every level of experience. Not only does he cover every important feature, but he follows the text up with a comprehensive API Quick Reference. Either half would be worth the price of admission. Whether you're a Java pro or just interested in playing with the language, this book is an absolute must. And unless you work at home, I'd buy two.

This kind of classic book has its merit, but this version has quite a few problems
We don't want a 'man page' like reference book, the list of member functions with NO samples or descriptions are closed to useless.
For example: I looked at section 5.4 about Calendar,here is the code:
// Display the current time using a short time format for the current locale
DateFormat shortTime = DateFormat.getTimeInstance(DateFormat.SHORT);
DateFormat myformat = new SimpleDateFormat("yyyy.MM.dd");
Date leapday = myformat.parse("2000.02.29");

I don't remember the SHORT and yyyy.MM.dd, so I decided to check the reference. In DateFormat page, the book says "The getdateInstance( ) methods return a DateFormat object suitable for formatting dates in either the default locale or a specified locale. A formatting style may also optionally be specified; the constants FULL, LONG, MEDIUM, SHORT, and DEFAULT specify this style."

Does that make any sense? no, I don't know how to deal with Locale and the difference between those MEDIUM,SHORT stuff.

So I check my SUN javaDoc in a lovely windows chm format, it says so clearly about all the information I am looking for and even with a few examples! It also even put explainations in lists
"SHORT is completely numeric, such as 12.13.52 or 3:30pm
MEDIUM is longer, such as Jan 12, 1952
LONG is longer, such as January 12, 1952 or 3:30:32pm
FULL is pretty completely specified, such as
Tuesday, April 12, 1952 AD or 3:30:42pm PST.
"

Then I check SimpleDateFormat in the book, it DOES NOT say anything about "parse"! The only thing it gives is:
public java.util.Date parse(String text, ParsePosition pos);

Come on, what is pos? I have to look for it in JavaDoc again.
It says "
Parses text from a string to produce a Date.
The method attempts to parse text starting at the index given by pos. If parsing succeeds, then the index of pos is updated to the index after the last character used (parsing does not necessarily use all characters up to the end of the string), and the parsed date is returned. The updated pos can be used to indicate the starting point for the next call to this method. If an error occurs, then the index of pos is not changed, the error index of pos is set to the index of the character where the error occurred, and null is returned.
"

What a shame to O'Reilly. I really hope in the next version they can:
1. Add some description to the most useful member functions in each class.
2. Add a simple example for each Class or add cross reference.
3. Add an idiom code sample for each class
4. Remove 'not that useful' member functions, so many classes have "clone, equals, tostring, hashcode" in it, do you really want to list them??

I've owned every edition since the first and I continue to recommend it. Part I is a great introduction to Java for novices. It is also great for experienced Java programmers to learn the new language features.

My only criticism is that over the years this "in a nutshell" book has expanded to the fill the size of a coconut. Starting with the 4th Edition, I began to recommend that novice Java programmers just read Part I. The author should drop Part II from subsequent editions as printing the Java APIs is a waste of paper and shelf space.

One has to wonder about an 'In a Nutshell' book that goes over 1000 pages, but that aside, this is one of the best Java books out there, no matter what your goals are.

New to Java? The beginning chapters outline how to use Java easily and in pretty good detail.

Want to become an expert in Java? Well over half the book is a reference to a bunch of the Java APIs, which will give you exposure to a lot of what Java can do.

Need a handy reference and don't feel like looking through the Javadocs? This book was designed with you in mind, giving you a handy reference section of about 700 pages to help you out.

Although I wouldn't recommend this book to someone with NO programming background, for anyone else this book is perfect.

Java in a Nutshell, Fifth Edition
By David Flanagan
Fifth Edition March 2005
Series: In a Nutshell
ISBN: 0-596-00773-6
1264 pages, $44.95 US
http://www.oreilly.com/catalog/javanut5/

This has to be one of the thickest "Quick Reference" books I've ever seen. The 5th Edition to Java in a Nutshell was updated to cover Java 5.0. The cover of this book under Java in a Nutshell reads "A Desktop Quick Reference". I understand how this book is more of a reference guide to Java rather than a run through of what Java is about, but the thickness of this book doesn't agree too well with being quick reference. There is a lot of this book to dig through and almost would benefit from a CD-rom version for the search functions.

If you need a complete reference book to Java including Java 5.0, this book is for you. This book starts with an intro to Java and goes right into the syntax of Java from the ground up and Java programs from the Top Down. Chapter 4 covering Java 5.0 Language features is a nice addition to this 5th edition book. Chapter 5 covers the Java platform and then Chapter 6 goes into the security of Java including security risks. The different Java Development Tools are covered in Chapter 8 which is where a lot of beginners will probably want to glance over.

The second part of this book is entirely a API Quick Reference, and here is where the book grows in thickness. I'm glad they added the first part of this part, "How to use this quick reference". Without this section, navigating between pages 385 through 1076 would be a bit more difficult when it comes to understanding how information is organized.

This massive book contains 2700 lines of cleanly commented code that demonstrates how common tasks can be accomplished. Demonstration code is always an added bonus in a reference book as it'll give you the chance to see how certain things are put together rather than just reading about them individually. It'd be nice if this book was a bit lighter but atleast it covers everything it needs to cover and then some, along with being fairly easy to navigate. This book combined with a few Step-by-step Java books would make a completely Java CD Bookshelf and would make navigation of the information a lot easier.

I'd recommend this book to anyone looking for Java information but this is definitely not the book for beginners to learn Java from.

Mitch Randall
Pensacola Linux User's Group

... and a solid "Java in a Nutshell" is one of them. What can I say? I started with v1.1 and have bought every version up to v5.0.
I can relate to the main complaint of the other reviews: the book's size. I agree that the second half of the book parrots the JavaDoc, but it is somewhat different and helpful, especially if you've grown used to looking through it to find stuff.
I don't know what the answer is. Hey, I have an idea: blame Sun, not David. At the risk of getting flamed and/or flack, I have oftentimes thought that the Java language is just growing out of control. Some might argue that we need all of this stuff. Perhaps that is true, but is it really worth the hit that each and every developer takes every time they try to find something is this vast ocean of APIs?
Ahh, remember the good old days of K&R "C"?

Recently, Sun gave us a significant upgrade to Java - the release of Java 5. A slew of the inevitable bug fixes. But also key new features, as explained here by Flanagan in the 5th edition of his long running reference.

Some new abilities lead to notational simplification, like autoboxing. So if k is an Integer, you can now say "k=5" instead of the clumsier "k=new Integer(5)". With a similar inverse process if q is an int, of being able to write "q=k" rather than "q=k.intValue()". Though of course the older forms are still valid, for backward compatibility.

Hey, varargs are now allowed! Much to the pleasure of some of you who came from C programming and used this nice feature. Ever since Java came out, there has been a continual, albeit quiet, push for varargs. Finally!

By now, experienced Java programmers may be familiar with earlier versions of the book. There may be mild astonishment at the sheer heft of this edition. Thanks to its popularity, Java has bulked up in the number and scope of its classes. The book is a reassuring sign of Java's vitality.