Variants Books

Java Phrasebook is a beautiful, well written book containing 100's of phrases which will help the reader to accomplish common tasks in Java. This book is for intermediate Java developers as well as developers who are new to Java.
The author assumes you have previous knowledge of Java and you are ready to program in Java; don't worry he has included references to various web sites (mostly Sun) throughout the book for additional information you might need.

The book covers JDK 5.0 and is not a Java language tutorial or introduction or even a reference to the Java language.

Personally, I found this book very easy to read, and carry; it fits in my purse. I do agree with what the author suggests; if your goal is to get a deeper understanding of a specific technology, this is not the book you are looking for.
On the other hand, this book should be very helpful for those who need to brush up some phrases before an Interview or even to those who teach Java courses.
I had seen foreign language phrase books earlier, this was the first technical phrasebook I read, and if you are indeed looking for one, I highly recommend this for Java.

This is a very odd approach for a Java reference book. The idea is that, if you are in a foreign country and cannot speak the language, "phrasebooks" for that language, showing you how to say common phrases without having to study the language in detail, are very helpful. That is true. However, those people who find such phrasebooks useful tend to board a plane and go home in a few weeks, with no real further use for the language. The problem is, how many times is that true in programming? Either you need to know the entire programming language, or you don't. This book is an attempt to use the same phrasebook approach for Java. In the beginning, it does a pretty good job of stating basic things you need to know such as setting up your environment, compiling from the command line, etc. that are usually not clearly stated in books that teach you the full-blown language. However, don't expect it to teach you the language. It might make a good reference for showing novices certain basics and maybe even experienced programmers might find it useful for a few useful "recipes" and tricks, but I found The Java Cookbook much more helpful and comprehensive in its coverage. The book's biggest weakness is it skips over the specific issue of object-orientation in Java. The following is the table of contents:

Chapter 1. The Basics
Compiling a Java Program; Running a Java Program;
Setting the Classpath;

Chapter 2. Interacting with the Environment
Getting Environment Variables; Setting and Getting System Properties; Parsing Command-Line Arguments;

Chapter 3. Manipulating Strings
Comparing Strings; Searching For and Retrieving Substrings;Processing a String One Character at a Time; Reversing a String by Character;Reversing a String by Word; Making a String All Uppercase or All Lowercase; Trimming Spaces from the Beginning or End of a String; Parsing a Comma-Separated String;

Chapter 4. Working with Data Structures
Resizing an Array ;Iterating Over a Collection; Creating a Mapped Collection; Sorting a Collection; Finding an Object in a Collection; Converting a Collection to an Array;

Chapter 5. Dates and Times
Finding Today's Date; Converting Between Date and Calendar Objects; Printing Date/Time in a Given Format; Parsing Strings into Dates; Adding to or Subtracting from a Date or Calendar; Calculating the Difference Between Two Dates; Comparing Dates; Finding the Day of Week/Month/Year or Week Number; Calculating Elapsed Time;

Chapter 6. Pattern Matching with Regular Expressions
Regular Expressions in Java; Finding Matching Text Using a Regular Expression; Replacing Matched Text; Finding All Occurrences of a Pattern; Printing Lines Containing a Pattern; Matching Newlines in Text;

Chapter 7. Numbers
Checking Whether a String Is a Valid Number; Comparing Floating Point Numbers; Rounding Floating Point Numbers; Formatting Numbers; Formatting Currencies; Converting an Integer to Binary, Octal, and Hexadecimal;
Generating Random Numbers; Calculating Trigonometric Functions; Calculating a Logarithm;

Chapter 8. Input and Output
Reading Text from Standard Input; Writing to Standard Output; Formatting Output; Opening a File by Name; Reading a File into a Byte Array; Reading Binary Data; Seeking in a File; Reading a JAR or Zip Archive; Creating a Zip Archive;

Chapter 9. Working with Directories and Files
Creating a File; Renaming a File or Directory; Deleting a File or Directory; Changing File Attributes; Getting the Size of a File; Determining if a File or Directory Exists; Moving a File or Directory; Getting an Absolute Filename Path from a Relative Filename Path; Determining if a Filename Path is a File or Directory; Listing a Directory; Creating a New Directory;

Chapter 10. Network Clients
Contacting a Server; Finding IP Addresses and Domain Names; Handling Network Errors; Reading Text; Writing Text; Reading Binary Data; Writing Binary Data; Reading Serialized Data; Writing Serialized Data; Reading a Web Page via HTTP;

Chapter 11. Network Servers
Creating a Server and Accepting a Request; Returning a Response; Returning an Object; Handling Multiple Clients; Serving HTTP Content;

Chapter 12. Sending and Receiving Email
Overview of JavaMail API; Sending Email Sending MIME Email; Reading Email

Chapter 13. Database Access
Connecting to a Database via JDBC; Sending a Query via JDBC; Using a Prepared Statement; Retrieving Results of a Query; Using a Stored Procedure;

Chapter 14. Using XML
Parsing XML with SAX; Parsing XML with DOM; Using a DTD to Verify an XML Document; Creating an XML Document with DOM; Transforming XML with XSLT;

Chapter 15. Using Threads;
Starting a Thread; Stopping a Thread;Waiting For a Thread to Complete; Synchronizing Threads; Pausing a Thread; Listing All Threads;

Chapter 16. Dynamic Programming Through Reflection
Getting a Class Object; Getting a Class Name; Discovering Class Modifiers; Finding Superclasses; Determining the Interfaces Implemented by a Class; Discovering Class Fields;Discovering Class Constructors; Discovering Method Information; Getting Field Values; Setting Field Values; Invoking Methods; Loading and Instantiating a Class Dynamically;

Chapter 17. Packaging and Documenting Classes
Creating a Package; Documenting Classes with JavaDoc; Archiving Classes with Jar; Running a Program from a JAR File;

It's a good book overall. It offers a more practical approach to object-oriented programming. The fun excercises challenged me enough to make me confident in each lesson. However, because it's only a first edition, there were numerous spelling and syntax mistakes. Nonetheless, I learned an incredible amount about Java and have now found a new hobby.

The authors have taken an interestingly different pedagogy to teaching Java to someone totally new to it, or indeed new to any programming language. Most texts on Java start off with describing the simple syntax, like for performing arithmetic, or inputting or outputting a string. These must necessarily be done within at least one class, since Java is very strict about this. But this approach is essentially the same as for earlier non-object oriented languages like C or Fortran. Typically, only later in such a Java text will object oriented discussions arise, or the use of graphics.

The novelty offered in this text is to emphasise from the very first chapter the object oriented nature of Java. This is aided by the use of graphics classes. The authors chose graphics because these give an immediate visual feedback to the student, that is very intuitive. This tight feedback loop can aid understanding or even the interest of the student. The two issues are often related!

Also, they do the student a favour by simplifying what can admittedly be a confusing melange of associated graphics classes, when you attach a Listener to a Java graphics object. Because then you usually need to write a class that implements that Listener interface, even if you won't be using all the methods. All this is needed under Java. But the authors finesse it by providing a class library which they call objectdraw. It lets the student focus on the key graphics ideas without tripping over the boilerplate. Later in the text, it reveals the usual gory details of what normally has to be done. Hopefully, the student will be experienced enough by then to take this in stride.

Another bonus about this book is that through its examples of an Integrated Development Environment, it encourages the student to adopt the free Eclipse. Thus far, Eclipse has been mostly used by experienced Java professionals. But it has very powerful helper facilities. Pushing it down to new programmers may well help them.

This book is extremely well organized and can be used as a reference and a text book for a college-level course. The many clear examples and exercises at the end of each chapter make learning Javascript a breeze. I also enjoyed the writing style and appreciated the enclosed CD. Highly recommended!

Good Book. Purchased for a College Class. Has alot of good examples in it and very easy to follow!

This book does a relatively good job of introducing the IFC from Netscape, but beware that some of the code that appears in the book does not appear on the CD-ROM. Contact with the publisher two months ago brought promises to hunt down the authors and make the code available, but I've yet to be notified that any of the missing code has been provided. Other code that IS on the CD-ROM is notably buggy, whereas the code in the book is often correct.

I acquired this book and a similar one, Mastering Netscape IFC, at the same time. This book was tremendously useful while the other one was a waste of time & money. You will be satisfied with this book if you want to really take advantage of IFC.

If you are new to 3D programming in Java then this book is not a very good place to start. That's not to say this isn't a good book its just that you will need to be somewhat comfortable with Java3D before reading this book. Like the previous reviewer said the sun tutorials will help to understanding the examples used in this book, just don't think that this book will hold your hand.

There is some overlap between this book and the author's other book on Java game programming, "Killer Game Programming in Java", but overall there is enough new material to make it a worthwhile purchase. The author starts out trying to explain Java3D. His explanations are OK, but the best explanation I have ever found as an overview of the API is "Java 3D API Tutorial" on the Sun Microsystems website. It's old, but the basics haven't changed. For the specifics of working with Java 3D in the modern era, come back to this book. The author has done a good job of putting together some programming examples that show how to program in current versions of Java 3D including a 3D version of Conway's game of life. He then modifies the program to show off some of the features of Java 6 such as its ability to communicate with scripting languages. Further chapters show how to build creatures with operational limbs that demonstrate Java 3D's TransformGroups, how to handle physics and Java3D using a specific physics API, multitexturing for more natural looking outdoor scenes, and finally how to deal with level of detail problems using mixed mode rendering. In each case, the author just doesn't talk about how to do something, he produces working code that gets the job done and provides a blueprint for the reader to go further.

The section on non-standard input devices deals with interfacing devices such as webcams, game controllers, game pads, and the P5 Virtual Reality Glove to your 3D worlds and games. He mentions parts of Java that are seldom well-explained such as JInput to describe how to control these devices. In the section on webcams, the author talks about JMF and an alternative method of interfacing to cameras. This is good, since for all intents and purposes JMF is really a dead API with very little useful capability. One of the more interesting chapters in this section really has nothing to do with input devices, that being the chapter on JOAL, which is a wrapper around OpenAL, the OpenAudio Library. This is very practical since there are bugs in Java 3D's sound interface that have been there from the beginning and show no sign of being resolved. This chapter provides a practical way for Java programmers to get actual reliable 3D sound into their games and applications.

The final section of the book is on JOGL, which is a Java wrapper for the OpenGL graphics library. The author explains and illustrates the use of JOGL by first implementing a very simple application to clearly illustrate all of the steps needed. Next, a 3D world is written using JOGL that includes a floor with a checkerboard pattern, an orbiting earth, a skybox of stars, a billboard that shows a tree, overlays, and keyboard navigation.

This book, along with the Sun tutorial, is a good education in how to use the Java 3D API in general, and also how to build virtual worlds in Java as well as how to write 3D Java games, which was the book's original purpose. Highly recommended.

I really liked this book. The explanations are very clear and thorough. I agree with the previous review, that the book is a little SWING and code heavy. The SWING stuff is however just used as examples to explain a concept. The author is not trying to teach you SWING through this book. I guess that also the reason for longer code samples. Swing adds a few extra lines of code to each sample, but without that .. it might be difficult to follow through.

Overall .. this is a good intermediate/advanced level book.

This book covers a grab bag of reasonably advanced Java topics. These include collections, XML, some database access, and Swing. Roughly half of the book is Swing. The first chapter, which covers library design, is solid.

The exposition is solid, if a little dry. The illustrations are good. The book does rely a little heavily on code to do most of the expository work.

I recommend having a look at this book in person before buying it. See if there is enough there on the topics that interest you to make it worth the purchase.

I have been a Java developer for five years now, and have worked with JSP and Servlets for a number of years. As many in the software industry can attest to, you can quickly get tied down working on applications that were initially designed several years ago. This can leave you with little time to explore all the new features that come out with the latest release of the Servlet and JSP specs. Wanting to get a handle on what JSP 2.0 has to offer, I decided to get a book on the subject matter that starts from the ground up. Although a lot of the material would be review for me, I always find it important to read this information over again as it helps to strengthen my overall understanding.

`Pro JSP' is probably one of the best books on JSP that I have read in a long time. To me a good technical book needs to do three things. First it needs to explain how the technology works. Second, it needs to explain how best to use this technology in the real world. And finally, it needs to do the first two things in a clear and understandable manner. The reader shouldn't be left scratching their head trying to figure out what the author was trying to say.

On the first point, `Pro JSP' does a thorough job of explaining the ins and outs of the JSP 2.0 release. The expression language, JSTL, tags, filtering, security, deployment; all of these important topics are covered. There are an amazing three chapters devoted to tags and another two chapters on filtering! The authors do an excellent job of focusing in on some of the more complex aspects of JSP and spending the time to fully explain all the nuances. Based on just the technical content alone, a person will walk away from this book with a solid understanding of the power available to them with JSP 2.0.

But of course `JSP Pro' doesn't just end there. Unlike many books that simply throw a ton of information at you and then leave you to figure out how to use it, this book goes much further. The authors spend a considerable amount of time discussing the best practices to use when including this technology in your applications. From repeatedly hammering home the need to keep scriplets out of JSP pages, to the chapters devoted to web application patterns and performance enhancements, the reader will be left well prepared to use their newly acquired skills on their own projects.

The writing itself is also very well done. The examples are short and to the point, and the writing is clear and understandable. I never found myself struggling to understand what the author was trying to convey, or tripping over complicated code to see the examples in action.

The only caveat I would have would be with the last chapter dealing with using `Struts, Xdoclet, and Other Tools'. The authors recommend that the reader have an understanding of these tools before reading the chapter. They then dive right in to how to best use these tools without a lot of explanation. This may be just a little too much for someone coming to this book as a complete beginner to JSP. This chapter will of course prove invaluable to a more experienced programmer, but the abrupt change of pace from the rest of the book felt a little uneven.

All in all I would definitely recommend this book to JSP programmers of all levels.

When I first bought this book was totally new to JSP and XML. I started reading it and then i realize that it was not a beginners book. It was great because it would force me to study a little bit more. I read a XML and JSP tutorial and it was enough to begin studying JSP with this book.
It has lots of detailed information about client/server persistence graphics and models too.
I bought this book because the history of the author, Simon Brown, and the last edition was five star recomendation on JavaRanch and Amazon reviews.

.. why is a book on sale in 2008 typeset as if it's 1970s? Is $40 per copy not enough to hire a designer - or provide a binding that is not going to fall apart in a week?

As far as content is concerned, my benchmark has been the SCJP prep book by Sierra and Bates. I took a random topic, generics, and how much more lucid and to-the-point the SCJP book was.

Although this book purports to be written for anyone with even a little bit of prior programming experience, I am finding it very difficult to follow. This, even though I have been dabbling in programming since 1976 and I have gotten 'A's in several programming classes.

The author makes three major mistakes all throughout the book:

First, he uses compressed code formating that makes it difficult to see where one part of the code ends and another starts. I know it is common for advanced programmers and authors trying to save paper to use this format, but it should not be used in a book for beginning Java programmers. I spend more time just trying to sort out which curly bracket matches to which curly bracket than anything else in trying to read his code.

Second, he continuously uses advanced techniques and Java features in sample code meant to illustrate beginning concepts. This leaves the reader confused about what the code is doing at all and forces them to simply take on faith that what the author says about the code is true. For instance, in the section titled "Your first Java Program" (page 78) the author instantiates an anonymous object and passes it to a method. There was no reason to include this line of code. But the author stuck it in there and then waved his hands at it saying merely, "The argument is a Date object that is being created just to send its va1ue (which is automatically converted to a String) to println(). As soon as this statement is finished, that Date is unnecessary, and the garbage collector can come along and get it anytime. We don't need to worry about cleaning it up." In those few sentences the author has made reference to several more advanced features without even explaining them. So, in trying to understand that one unnecessary line of the reader is spun off on at least three different tangents.
The next sample program is even worse. The very first line that actually does anything is " System.getProperties().list(System.out); " Holy cow! The System.getProperties() method returns a Properties object which is an extension of the Hashtable class. Then the second dot operator calls the list method for Properties object that has "replaced" the System.getProperties() part of the code as far as the second dot operator is concerned. The list() method then accepts as an argument a static PrintStream object which the list() method then sends its output to. And the author says merely, "The first line in main( ) displays all of the "properties" from the system where you are running the program, so it gives you environment information. The list() method sends the results to its argument, System.out." But to someone who is only just now reading this page in the book, "System.out" is how you print something, NOT something that can be passed as an argument. And have you ever tried to Google a period (.)? How is a beginner supposed to figure out that the list() method is a member of the Properties object that was returned by the System.getProperties() method. Sure, you can dig it out of the JavaDocs but a beginner won't be able to do this easily. Besides, if you are going to force the reader to dig everything out of the JavaDocs then what the heck is the book good for?
This same pattern is repeated throughout the book. Every single example has something in it that is more advanced than a person who has gotten to that part of the book could reasonably be expected to be able to figure out.

Finally, the biggest problem with this book is that the author has created his own set of libraries and uses them heavily in his code but doesn't indicate where. So, if you don't have the entire JDK memorized you have no clue when he is using something from the standard libraries or something from his own libraries. If you are trying to learn the basics of Java, you don't want to have some other stuff mixed in at random. Sure, the author's libraries may solve some interesting problems and it may make some things easier to code. But it DOES NOT teach the reader about how Java works other than it is possible to completely obfuscate everything you do.

So, my conclusion is that this book is really good for nothing. It is too confusing for the beginner and is way too wordy for an expert. Intermediate users will spend more time digging through the JavaDocs than they do reading the book.

Ok, I have read about 200 textbooks or better in my day, 20 - 30 or so in the programming area, and I have to say this was the worst text book I have ever looked at. It was poorly written and poorly organized.

This is a beginner addressed book on Java: if you are already skilled in programming with procedural or even OO language, you'll find this book very useful.
The text is very simple and clear, the examples are incisive and at the end of each chapter you'll find a couple of exercises that can be very useful to focus the concepts.
A "thinking in enterprise java" would be a great successor to this good book.
5 stars!

Thinking in Java is a quite comprehensive book for intermediate to advanced level for Java programmers. Each chapter can be read individually in order to learn inner details of Java 5/6 language. This is not a book for a new comer to Java language.

I used this book as my primary study guide for the Programmer Exam and it definitely helped me passing with high score.

This book is just right for this exam and covers all the objectives very well. I would certainly recommend anybody who is planning to prepare for the exam to read this book. Even experienced Java Developers can gain much of the knowledge of Java Language Fundamentals by reading this book.

However, based on my experience with the exam questions, I believe, this book is somewhat light on topics like Garbage Collection and Collections. If you aim to pass with high scores, you need to put more stress on these two topics and hence need to supplement this book with additional resources/tutorials freely available on the Internet. Otherwise, this is just right for the exam.

Obviously no one made a CURSORY proof-reading of this edition, or they would have seen dozens of double-quotes in the examples appear as some odd character I have never seen before. Once I figured it out I could decode what was meant, but it was a distracting nuisance. Obviously no one made a DETAILED proof-reading of this edition, or they would have seen us taught the size in bits of a double as 16 instead of 64. Obviously no one made a PROGRAMMING proof-reading of this edition, or they would have seen 65 listed as the byte-code of a lower-case 'a' in one of the exam samples, which made me choose "none of the above". Because of the errors which I DID see, I had little confidence in anything else that seemed questionable.

The chapter on Collections (which was probably added in this edition as it is new in 1.4 I believe) was not detailed enough, and didn't satisfactorily answer the chapter's own review questions.

The sample exams were not anything like the real one, which I failed. I kissed that $150 goodbye.

I studied this book carefully twice through and passed the exam easily. It may not be perfect, but it was all I needed.

I find it hard to believe that a study guide this error ridden was ever released given the gross errors my study group has found. We feel a lack of confidence in the material presented in this text and in the authors in particular. We have to verify everything presented in this text and believe nothing to be true without doing so. This is not a good way to study for a certification exam. We need a trusted and reliable reference, not a work of fiction.

We are not at all pleased with the material covered. Nor are we pleased with the mock exams which we all agree are too easy.

In all I would suggest that you not purchase this book and wait instead for the next release of Kathy Sierra & Bert Bates book.

The exams on the accompanying CD are crap.
The engine is buggy (sometime you cannot see the whole text) and answers are wrong. E.g.
Q: "Which access modifier will allow access only within the class and package?"
A: "friendly"

Maybe friendly, but definitely wrong.

If you do not understand servlets and program in Java this book is for you. I found it very easy to read and comprehend right off the bat. The examples are excellent and you will get off writing servlets very quickly. It is somewhat shallow in complex examples but then again how complex are servlets. Some best practices and commercial examples could have helped a lot.

I found this book to be semi helpful. It would have been nice if it was more tutorial like. The examples also were not the most straightforward. The book does cover alot though.

This book's examples in later chapters may be a bit much for the beginner, but it does a good job of covering thing very well. Good coverage of various protocols, etc.

I wouldn't say this is an excellent book, but it's not bad. The book covers good fundamentals in its first 8 chapters for those beginning Servlets. The book also covers some useful information on JDBC and Java Server Pages. There's also some additional coverage on Applet-Servlet communication, Internationalization and Tea & WebMacro application frameworks. However some topics like JavaBeans, SSL, Filters, deployment descriptors and XML were too brief and should have been given some depth. Another dissappointment is that all examples are based on API 2.2 but not 2.3!!. The Appendix just touches on new features of API 2.3 with also a separate listing of API 2.3.
It's been 8 mths since I purchased this book. I'd suggest that starters either wait for the next edition or get something that is based on Servlet API 2.3.

I completely agree with the 5-star positive reviews listed here. I saw a couple of new ones that were not so positive, so I wanted to voice my opinion.

This book is very well written - well structured, with in depth explanations, humor, good code examples. It can be used both as a tutorial and as a reference.

Even though it may be showing its age now in a couple of places (e.g. Tapestry is not mentioned, uses JDK 1.0 and 1.1 for the examples), it is still very good. It paints a complete picture, so one ends up with understanding of the principles and architecture - which is what matters - for the updated APIs there is always JavaDOC.

I don't know how suitable it is for beginners, but for an experienced programmer it is a thoroughly enjoyable read - once I started it I couldn't stop until I finished (I didn't actually type the examples - that isn't necessary for understanding the material) .