Customer Reviews

Java in a Nutshell, Fourth Edition

5 star:		(5)
4 star:		(8)
3 star:		(7)
2 star:		(6)
1 star:		(3)

 

 

Nothing makes the importance of understanding exactly what you are looking for as obvious as the travail of picking the right technical book from the usual host on a particular subject. And no subject seems to underscore this more than that of the Java language. I can limp along adequately in Java, after several corporate efforts to get it drilled into my skull, but I'm past the age where perfect recall is anything else but wishful thinking. And Java, which is more an architecture than it is a language, puts high demand on knowledge retention abilities.

Thus, I recently found myself searching for a language/object/method reference that is useful when reading and writing code, but does not require two briefcases to carry around. In those circumstances anything that says 'nutshell' is going to get my attention. Since I wasn't looking for long, flowing dissertations on syntax or object use, this book seemed exactly what I wanted. And it is, for the most part. There are about 300 pages of tiny print on Java, its syntax, environment, and tools. Then comes 600 pages of reference on objects and methods, organized (somewhat) by package. In general, if you can find it, and you already have a clue of why you should look for it, the book does just what I wanted.

The flaw, however, is in the finding. Indexing and organization is best described as adequate. But browsing is a literal impossibility. Under no circumstances should you buy this book if you are looking for a learning tool. It is at its best when you need to be reminded about something, not when you are looking for a way to actually do something.

I didn't expect to find anything on J2EE in the book, and sure enough, there isn't. But I found the lack of information on the AWT and Swing irritating. I admit that it says right on the back cover (in tiny print) that I need 'Java Foundation Classes in a Nutshell' if those are also of interest. Of course they are if you are writing an application that needs more than a command line interface. Left up to me I would have sacrificed some of the more obscure information for 50 or so pages on the AWT. Or even put up with a book with 100 extra pages. As it is I still need ten pounds of paperbacks to feel like I have sufficient reference material.

Still, the book of professionally done, brooks no nonsense, and does precisely what it says it does. Which is a small miracle in today's technology business. I certain bear a certain amount of responsibility for not getting something that is precisely what I wanted, but I use this every day, and generally, I get exactly what I need.

The java in a nutshell series was the most often used book in my arsenal off reference books. That was until now. Many of the most useful features of the previous three editions have been removed.

First the "tabs" printed on the edge of the book which would help you quickly find a package are now gone... so now I have to flip through MANY pages just tho find tha package I want...

From there I now have to find the class I am looking for, but the are not necessarily listed alphabetically anymore either. For example java.util.prefs.Preferences is on page 710, and java.util.Set on 677... ordered by package, leaving you with more to page through. Not exactly intuitive.

And the package heirarchy diagrams are gone now as well.

Its a reference book, but certinaly not a "quick" reference. I highly reccomend buying the third edition, but stay away from this one, at least untill they put the tabs back!

I've owned every edition of this book. As an instructor and occassional consultant I've found the ability to thumb quickly to details of the increasing numbers of classes invaluable. I've also found the introductory summaries useful as a refresher to parts of java I have not visited for a while, and in this edition they provide a quick overview of the new features of J2SE 1.4. This was never designed as a book for beginners, and to date has done what it does well.
Unfortunately two things have been changed with this new edition. Firstly, the ability to quickly thumb to the classes I want to know about has gone because the visible page-edge marks have GONE making the entire reference section one white blur of almost 600 pages. It now takes me roughly 5 times as long to locate a desired package. Secondly, the diagrams illustrating the class/interface hierachy for an entire package have gone. These were excellent overviews and are sorely missed. Finally, the book can no longer keep to it's 'NutShell' title weighing in at almost 1000 pages.
I will make a lot of use of this book as there is nothing I know of in paper form that contains all the information, but I believe the nutshell market has unfortunatley been cracked.

To clarify another review that listed the limited coverage of the new features in 1.4, the coverage of the new features is:

1. Assertions: 12 pages.
2. Logging: 16 pages.
3. New IO: 62 pages.
4. XML: 62 pages.
5. Preferences API: 9 pages.
6. JASS and JSSE: 22 pages (JAAS), 16 pages (JSSE).
7. Regular Expressions: 9 pages.
8. Security: The same as the 3rd ed., and the additions of JAAS and JSSE.

This includes, of course, the information in the quick-reference section, which the previous review omitted. And this is the best part of the book, and this edition: the structure expected in Flanagan's reference remains, but it has been refined (including class heirarchy diagrams for each class, not just for each package) and elaborated. While it may seem overly simple -- it is mostly a listing of the signatures of every public method in every class -- it is invaluable when programming, for it answers the question of *what* the name and parameters of methods are. The *how* to use them is ultimately left to the programmer; the book does not hold your hand.

Thus the book is, of course, merely an overview of the core Java classes. But it summarizes a very large and very complex API in a logical and easy-to-use manner, and those in search of detail on any single subject are better off purchasing a book on that subject.

The only clear fault with this edition -- and it is a major one -- is the omission of the thumb-indexes from the quick-reference section. This makes navigating this most important part of the book more difficult, and I think the use of a magic marker on the edges of pages will become necessary. Except for this flaw, this is a five-star reference, still.

Java in a Nutshell has been the definitive Java reference since the earliest days of Java. I've personally worn out multiple copies of each of the prior editions. However, the fourth edition takes the series down a very bad path. Why?

1 - The class references do not have the tab markers or any sort of page identifiers that let allow you to flip to the correct section. This makes the class reference (which is the most important section) all but useless.

2 - package overviews (namely the class hierarchies for each package) have gone. This was VERY valuable information for many sub packages.

3 - 900 pages is a pretty huge nutshell! This book needs to be seriously trimmed. O'Reilly already has a seperate reference for J2EE and Swing. There has to be a way to split this into 2 volumes because this is just far to big for a nutshell book.

I am very disappointed in the fourth edition of Java in a Nutshell. I hope O'Reilly can put out a better 5th edition or a revised 4th edition because the reference as it stands now is not useful.

This book is aimed at those who either already know Java or want to learn it in an efficient manner.

Some learn best from a book where the author jokes around and has all the info spread out, and slowly brings you up to speed, covering a topic, and then going back to cover it later in greater detail. The reference section would be integrated into the text in the appropriate places. If that's what you are looking for, this book is NOT for you.

For those with a previous programming background wanting a no-nonsense way to quickly learn how to program in Java, this book is EXCELLENT. There are no wasted words. The author gets down to the point and writes clearly. Each topic is covered in detail as it is presented. It is very possible to learn Java with this book and Java Examples in a Nutshell (I did it and I had no object oriented programming background, just assembly, C, and Basic). You'll also want Java Foundation Classes in a Nutshell (for AWT and Swing classes and methods).

There is a great index at the back. By its thickness and detail it is obvious that a lot of time was spent here. There is a separate index from the regular text index for listing the packages, classes, and methods. If you don't know what class a method belongs to, you can quickly find it here. I find the index section to be one of the best features of the book and quite useable.

The second half of the book is the class reference. This information can be found online, but the benefits of having it in book form are many: I can write in the margins, I'm not constantly flipping back and forth between windows, I don't have to worry about the format changing, an frankly, the information is presented in a much more understandable way than the way Java decided to put it on their website.

About the reference: You wont find anything about AWT or Swing, they are in Java Foundation Classes in a Nutshell. Some reviewers have claimed there are no printed tabs in the 4th edition. This is false. There are gray/black tabs printed along the edges. My only gripe here is lack of printing on the book edge of what the tabs are, but I wrote that on the edge with a pen. At the beginning of each package a class hierarchy is presented. This is invaluable, especially for the java.io package (if you ever got lost with all the Reader and InputStream combinations this is a godsend.) In addition, the major classes will have a nice graphical chart so you can trace them back to Object. Each object has a full method list, with version numbers for those methods appearing after Java 1.0. It should be emphasized that this method list is presented in a very easy to read and visually clean format. Properties will have the default value printed. A summary of how to use most of the methods is presented before the method list. Usually this gives enough info to understand on its own, but some methods are not summarized. These summaries should be expanded in future editions to cover each method, and in greater detail. At the end of each object additional information is given about what other objects use the object, or return it. Also, there is no reason the class hierarchies can't be put at the top of every class.

One thing missing from the reference section is example code for each class. However, I can't think of a way this can be added without turning the book into an encyclopedia set. It's already very thick as it is.

I am very happy with this book. I recommend it to everyone I know as THE Java book to own. Don't take a Java class without it. I was the envy of my class, writing programs with ease. Others rewrote standard classes from scratch because they didn't know where to find them.

5 out of 5.

I don't really think that this book is very useful for anyone except for beginners. More than half of the book is an API reference. There is an entry for every class in the Java packages, but I can't see what purpose they serve. There is a brief discussion of the class as a whole and then a list of the fields and methods in that class. But there is no discussion of the individual methods and you can't really get a good idea of how to use the class. You still need to consult the API documentation to use any class with which you are unfamiliar, so why would anyone ever bother using this reference?
The first part of the book is a rather standard introduction to the Java language and the core APIs. I haven't really found this that useful either. The one part of the book I have used a lot is the reference to the Java tools that come with the SDK. This section lists all the command line tools (like java, javac, javap, appletviewer, etc.) and discusses the command line options for each. Very useful, but hardly worth the rest of the book.
For an API reference, you can't beat the API documentation from Sun's Java website - plus it is HTML so you can always have it on you computer. For a syntax reference try the "Java Programming Langugage Specification", or the slightly watered down version "The Java Programming Language", both by James Gosling - who invented the language in the first place. And for real example code, I really like the sister book to this one - Java Examples in a Nutshell. This is a very useful book indeed.

This is a LARGE nutshell! This title is meant to be one volume of a three volume set that covers the entire language. Volume two covers the foundation classes, while volume three covers the enterprise classes.

If you're just starting out with Java and you're trying to learn the language, this isn't the book for you. While Part 1 could be used as instructional material, it is truly "no fluff". It's best suited for an experienced object-oriented programmer making the leap to Java, or a Java programmer looking for a concise review. A good learning book would be "Learning Java" by Pat Neimeyer and Jonathan Knudsen from O'Reilly.

The really valuable part of this book is Part 2. Each chapter defines the classes in that package with an explanation on what it does and how it works. There's a diagram that shows the class hierarchy from the root Object class, as well as what version of Java supports that class. This is then followed by all the constructors and methods used in the class. Don't expect detailed explanations on these methods. As a nutshell book, you get all the basic info on what's available, but you'll need to experiment with some of the methods before you understand them.

A legitimate question might be... Why get this book if I have the online API documentation from Sun? I see them as complimentary. You can probably find much of the reference material in either source. Some will prefer the online hyperlink navigation, while others will appreciate having all the information on a subject in four or five pages that can be thumbed through. I know when I'm stuck on a problem I want both sources!

For a Notes/Domino developer, it is somewhat similar to using online Notes help versus the manuals. In that case, the material is identical, so it's more your preference in how you like to look up information. In the case of this book versus the Java API documentation, you'll get good information from both sources, so you should avail yourself of both.

Conclusion
If you've completed something like Teach Yourself Java In 21 Days and now you have to DO something with Java, you owe it to yourself to get this book. This will be one title you'll go back to again and again as you explore the wild, wild world of Java.

While this book is 3 stars, having a refernece of many of the core classes is very handy, especially for those that the understand OO paradigm and are quick learners like me who don't need to walked through the classes with tons of examples - Just show me what's available and let me learn on my own. That's essentially what this books allows you to do, as this book is not really meant to teach but to provide an overview of the Java Platform. Being updated for 1.4, you can get up to speed on the XML classes and the new non-blocking IO library. This book is essential for new to say 2-year venteran programmers that would to have everything in a book and don't know all the classes in the API yet.

This book is way too terse to be useful. Modern Java development tools will help you use the correct class method signatures anyway. Buy the posters instead and give yourself a visual overview instead.