Customer Reviews

Java Cookbook

5 star:		(23)
4 star:		(5)
3 star:		(2)
2 star:		(4)
1 star:		(0)

 

 

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!

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.

I'm blown away by how much better the second version has improved from the first. I was so disappointed by the first edition that I swore off O'Reilly for a little while. One of my major gripes, the rampant use of classes provided by the author in libraries has all but vanished. In addition the anti-patterns of bad SQL use that are so rampant in other Java books are nowhere to be found, and in their place are recipes that show sane and proper use of JDBC.

I heartily recommend this practical work for Java engineers. For those not familiar with the first edition this is a solid practical work that covers a wide range of Java programming challenges. For those turned off by the first edition, you should take a look at the second, the improvement is profound.

If I'd had this book two years ago, I would have saved myself weeks of work. As a software developer of some twenty years, I find that the ever-present problem of `looking things up' is the major factor that impedes progress. I've spent hours trying to track down `how-to' solutions only to find in the end all that's required is a few elusive lines of code. Well, the Java Cookbook is filled with such code along with insightful explanations.

I'm impressed by how comprehensive the coverage is: 26 chapters covering such things as file i/o, Swing, RMI, applets, Java Servlets, JSP, e-mail, JDBC, XML, multi-threading... At 48 pages, the index is HUGE, just what you need to look things up!

The author assumes you know Java but not as well as you ought to! He explains all those things that I really should know but I never get around to figuring out properly: the correct handling of dates/times, internationalization, floating point numbers, etc. Thankfully, the book is concise and easy to read so you can quickly plug a bunch of gaps in your knowledge by browsing over chapters.

This book will quickly pay for itself. Enjoy.

Anyone who has been involved in programming very long soon comes to realize the value of the various programming cookbooks. The cookbooks are not for the person who wants to learn how to program in a particular language, but are very useful for programmers with a basic knowledge of the language. The idea is simple, take the most common problems people deal with and put the solutions into a book. Simply state the problem and then show the code to resolve it. So, if you need to know how to do something you can look it up, enter the code, and test it.

Some of the chapter subjects include Interacting with the Environment, Strings and Things, Pattern Matching, Numbers, Dates and Times, Object-Oriented Techniques, Directory and Filesystem Operations, Graphics and Sound, Network Clients, Server-Side Java, Database Access, XML, and Threaded Java. Typical of any of the programming cookbooks, it is a quick and easy source for answers. Each item has a short explanation of the problem and then goes straight to the code to demonstrate how it works. A great time saver and required resource for Java programmers, Java Cookbook, 2nd Edition is highly recommended.

I make no apologies about being an "R&D" developer... "Rob & Duplicate". I learn best by seeing something that works, and then adapting it to my own needs. Therefore, a book like Java Cookbook by Ian Darwin (O'Reilly) is the exact type of book I look for and use on a regular basis.

The chapter breakdown: Getting Started; Interacting With The Environment; Strings and Things; Pattern Matching with Regular Expressions; Numbers; Dates and Times; Structuring Data with Java; Data Structuring with Generics, foreach, and Enumerations; Object-Oriented Techniques; Input and Output; Directory and Filesystem Operations; Programming External Devices: Serial and Parallel Ports; Graphics and Sound; Graphical User Interfaces; Internationalization and Localization; Network Clients; Server-Side Java: Sockets; Network Clients II: Applets and Web Clients; Java and Electronic Mail; Database Access; XML; Distributed Java: RMI; Packages and Packaging; Threaded Java; Introspection, or "A Class Named Class"; Using Java with Other Languages

For those unfamiliar with the "Cookbook" style, the chapters have a series of real-life problems, such as playing a sound file, playing a video clip, and printing in Java. The problem is followed by a short one or two line solution and an expanded discussion of the issue complete with code. This approach makes it really easy to find something that is similar to the issue you're facing and to see how someone else would solve it.

For me, the quality of this book is really high. It's a second edition covering the Java 1.5 package, so it's fully up on the current technology. In fact, the Generics chapter deals exclusively with new features in 1.5. Some of the solutions are code classes developed by the author and made available for download. But unlike some books I've reviewed where the author supplies code, this isn't an attempt to push their company or product. It's just a clean way to use a solution that someone else has worked through.

This isn't a book you'd use to learn Java from scratch, but it's a book you'll use on a regular basis as you continue to expand your Java knowledge. Highly recommended.

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.

I'm very into a method of programming called "R&D"... that stands for "Rob And Duplicate". I'd rather not invent or reinvent something if I can "borrow" someone else's solution. Given that as my mindset, I LOVE this book!

While the hardcore reference books are necessary, all too often the beleaguered developer is left asking for a simple example of how something works in a real program. Sometimes it's nice just to be able to see a class (like the Java I/O classes) used in the context of a complete solution. From there, you can figure out how to start using the class in your own program. That's the real value of this book. I may conceptually understand what a class does, but it's sometimes hard to translate that knowledge into syntactically correct code. Seeing an example helps me get a grasp of how it is really used.

For Notes/Domino 5 developers, this is an extremely useful book. Many Notes/Domino developers are used to using and sharing solutions that have already been coded and solved by others. This book will feel very natural to them. It allows you to get a core set of code working, and then from there you can expand to work into a complete coding solution.

Conclusion
Regardless of where you are at in your Java career, you should have this book. If you're a Java newbie, it will help you bridge the gap between reference manuals and real programs. If you're an experienced Java programmer, it will give you different perspectives on how a problem could be solved.

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.

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.