Rating: 
Summary: A cookbook indeed!
Review: If you are a Java novice with an interest to learn quickly how the Java language is used without wanting to dwell into the fundamentals, this book is for you.On the other hand if you want to learn the Java language throughly, this book will make you learn the wrong habits since it contains several subtle errors that will escape a novice's eye.
Rating: 
Summary: A comprehensive reference of Java progamming solutions
Review: If you've progressed beyond the beginner stage of Java programming and need a comprehensive reference of programming solutions, this book is an outstanding choice. Extremely well written in a friendly, conversational style, it includes several hundred code and program examples for common tasks. The book is thoroughly indexed and cross-referenced, and you can get all the source code from the publisher's website. Each of the "recipes" clearly describes a programming task and suggests one or more solutions. The introductory chapter includes valuable suggestions on program development and debugging. For a long time my standard Java help book had been Flanagan's "Java Examples in a Nutshell". While that is still a good reference, Java Cookbook is what I'll be using from now on.
Rating:
Summary: O'Reilly does it again
Review: Nice addition to my Library. Very Handy, goes well with my Java Examples in a Nutshell.
Rating:
Summary: Invaluable reference guide
Review: Ok, You've been writing Java code for months, maybe even a couple of years. Objects aren't anything special... they're just the natural way to do things. You don't even need to LOOK at the Servlet API anymore. You might even have a SCJP or SCWCD under your belt. Then, for the first time in years, it happens: you need to interact with a real, honest-to-god file sitting on the hard drive. Or parse a String into a Date object. And this time, you can't just throw the job at Tomcat or JDBC and let it do the dirty work for you. And to your absolute horror, you realize that you don't have the slightest clue in hell how to do it in Java. That's right... simple, trivial things like file i/o. Something stupid, like reading a text file into a String. After cursing Gosling and Sun for a half hour for not giving String a constructor that takes a File object as its argument and making things that should be trivially easy to do needlessly complicated [ok, all in unison... 'if ((foo != null) && (foo.equals("whatever")))', vs. 'if (foo == "whatever")' ...], it sinks in: You don't know how to do it. Well, OK, that's not quite fair. You have a general idea. Hell, you did it all the time in Perl and C++. You know it probably has something to do with java.io.File, and following the deprecation chain from java.util.Date will lead you to java.util.Calendar. But the devil's in the details, and trying to figure out how to do it from the javadocs alone isn't exactly the most efficient way to burn an afternoon. Especially since all the nice, convenient methods that let you ignore ugly things like character encoding were deprecated LONG ago. Ditto for date parsing. OK, so you dig out the old books you haven't touched in months, maybe years, on introductory Java. They ignore the topic completely. File I/O? Date parsing? Ewwwwwwww. That's *so* 20th century. Objects, Swing, and j2ee are SO much sexier and profitable to write about. What? You really DO need to soil your hands and do it? Well, you'll have to look elsewhere. That's where this book comes in. It covers all the non-glamourous stuff that 99% of the books on Java more or less ignore or gloss over. Things like I/O. Text handling. You get the idea. The stuff that everyone wants to just delegate to the servlet container or database, but occasionally you really DO need to deal with directly. There's not really anything in this book that you can't find online. But that's not the point... you can blow an hour or two scavenging the info and experimenting to make it work, or you can get the answer in 2 minutes with this book. Buy it. BEFORE you need it. You'll be glad you did.
Rating:
Summary: Practical Examples Beyond Basics
Review: OK, you've learned the basics. You know 'public static void main string args' from a hole in th ground. What now? I teach Java at a college. Only a small percentage of my students are CS majors. Most introductory java books lack good practical problems to solve. The Java Cookbook is a list of common problems and code examples on how to solve them. I learned more in two days with this book than I did with several very good java books because I need to see examples and how things work in context. If you're like that too, you'll love this book. I pack it with my laptop so I'm never without it when I need it -- it's that useful to me!
Rating:
Summary: Very Useful Book
Review: One of the best Java books in terms of usability. All their examples are extremely useful in day to day Java programming.
Rating:
Summary: "A Fast Food" cook book
Review: The author attempts to cover all the APIs of jdk1.2 through examples in this book which is very good. The examples are plenty and would impress the Java novice. However, the mistakes in the examples would generally not escape a professional eye. David Flanagan's book, Java Examples in a Nutshell, with its throughness is by far a superior book.
Rating:
Summary: Wonderful
Review: The book is just what it promises to be and will be a great help to intermediate Java developers.
Rating:
Summary: More than a cookbook
Review: The examples in this book are truly useful. I am an experienced programmer just starting with Java and in finding an answer in this book, I often discover better ways of doing related tasks as a welcome side effect. In addition, the author presents each code example with a thorough and useful explanation. His writing style and attitude are humble, opinionated, direct and humorous. This is the only book in my java collection that's a pleasure to read. I tried using Java examples in a nutshell... I haven't picked it up since obtaining "cookbook". Plus I look to "cookbook" first before either java in a nutshell (except for simple reference) or java servlet programming.
Rating: 
Summary: Half-Baked Recipes
Review: The idea of a Java Cookbook is a good one. This book is very similar to the popular and widely acclaimed Perl Cookbook. Even though Perl is more useful for short stand-alone programs and Java is most effective in large-scale systems, a lot of Java code can follow a standard "recipe". For example, writing an equals method is a very common and surprisingly difficult task, so having a standard template available along with a discussion of important points is necessary for all but the most advanced Java programmers. To judge the quality of the recipes, I checked out some very basic and common Java problems, such as writing equals and clone methods, synchronizing threads, and comparing floating point numbers. In most cases, I found flaws in the code or accompanying explanations. The discussion of equals doesn't mention that the hashCode method needs to be compatible with it. The recipe for clone has the method unnecessarily throw a CloneNotSupportedException. The explanation of synchronizing threads says that locks are held on methods, instead of correctly pointing out that locks are held on objects. The code for floating point comparison requires that the user keep track of the magnitude of the numbers being compared. By using the term "Cookbook" in the title, I expected to find a collection of the best standard code templates. Instead, I found code samples that merely demonstrated a basic concept, and that they serve as only a starting point for understanding Java. Together with the misleading explanations, this book has the potential for confusing beginning Java programmers as much as it guides them. This book is best used as merely a guide to get the beginning Java programmer started. The "recipes" should be viewed as started points to be improved upon -- using them as is will result in less than optimal Java code.
| 
