Rating: 
Summary: Overrated
Review: The more I read, the lower my opinion became. The writing is neither clear nor concise. The compensation is a wealth of didactic programming examples. Unfortunately, the sample code is poorly formatted and arranged; important lines are overwhelmed by routine code (which was added so the reader could run the program); and lines not explained in the text require a separate reference (eg Sun's online API documentation). The book addresses itself to valuable material, but hasn't some other author done it better?
Rating: 
Summary: Excellent Book!
Review: This is a very good book, following up the 1st Edition which also was very good. The new edition is updated with the latest Swing and other improvements to Java. There is a companion CD audio/visual course that goes along with it sold on the author's website... It is actually all the audio and slides from a 3 day class the author teaches from time to time, which he uses the book as a reference and also uses the exercises out of it. I highly recommend buying the book and then buying the tutorial that goes along with it. It is a good book both for those starting out in Java,and for those experienced in Java needing both a review and an update on the more subtle aspects. The author explains Object Oriented Design quite well for those who are new to it also.
Rating: 
Summary: A must read for anyone new to Java
Review: Very readable book with lots of examples and useful pointers for any new Java programmer.
Rating: 
Summary: Someone Should've Splurged for an Editor
Review: Aaargh!! Maybe it's because I'm coming into programming via a journalism background, but I can't make heads or tails of most of what Eckel is saying. For Christ sake man, didn't you get anyone who was NOT a programmer to try and read and understand this book. I don't advocate the "For Dummies" oversimplification of things, but please, work with me a little. I'm selling this one and trading it for one in the Wrox series.
Rating:
Summary: A very good starter
Review: If you had graduated from school recently, and would like to take a career in Java, this is the book that will appeal to you the most. Why am I talking about the propensity of this book for new grads? Simple. It has a text-book approach throughout. However, the author takes enough pains to go out of the way to lay strong emphasis on the basics. Sometimes the details are so overwhelming, that you would tend to think as though you are being led astray. But, I bet you that such hard taming of the subject will surely make you a Java Guru. In Tamil language, they say, "A modicum of rice, would prove the worth of an entire feast". To prove the indispensability of the book, please go through Chapter 4 - Initialization & Cleanup. If I had paid the money to get this book, I am satisfied for just this one simple chapter. I can boldly talk about Object initialization now. I used to tease some of my friends who had been in the Java field for years working in EJB and other cool stuff.But when I throw a simple question on Java Objects initialization, they fall apart. This is not strange. This is not unusual. Because, any book in the market tends to shrug off such topics as of little importance. However this book has lots of basics covered with fine detail, that would only be very appealing to a majority of developers out there. On the cons side, some examples are just mere verbose kind of stuff, running into pages. That is kind of sickening ad nauseam. There is practically no continuity in the examples, unlike some related examples in Core Java book. Overall a very good book for a building a robust fundamental base in Java.
Rating:
Summary: Proof again that Programmers can't communicate
Review: This book is aimless, haphazard, badly organized, confusing, and does not do a good job in introducing core concepts in Java. It's one thing to know something about a subject...it's entirely another matter to be able to effectively teach it to someone. Long-winded, boring, misleading, no output to illustrate code examples, diffuse, BAD. I don't understand how this book got so many 4 and 5 star ratings. Maybe the average Programmer reading this book is immune to incoherent writing styles.
Rating:
Summary: If you want to know Java, read this book!
Review: Hi, there; "Thinking in Java 2" is really a fabulous tech book that dig into the Language. The author stand in a philosophic level to discuss aspects of Java. This is the most tech book that I have read. I rank this book No.1.
Rating:
Summary: Great as a reference, Good for reading
Review: This book comes in handy as an excellent reference for the beginner Java programmer. As many of you know, when it comes to Java it is almost impossible to fit everything into one book. Bruce Eckel does a good job of creating an overall reference book. If you are picking the book up for a front to back read, this is a bit harder. The first 200 or so pages are exceptional. Bruce brings up some overall points that I agree with 100%. However after page 200 or so it becomes a reference book. At least for me, reading a reference book front to back simply is not possible. Good book overall. A must have for the beginner Java programmer!
Rating: 
Summary: not a very helpful reference
Review: this book has been pretty useless as a reference book. The author covers too many topics but doesn't stay focused on one topic. He mentions available features of Java but does not provide very good examples on a particular subject. I had a much easier time finding good examples and explanations in the Exploring Java and Core Java books.
Rating:
Summary: Too haphazard with too much buried in code samples
Review: I was extremely disappointed in this book after reading all of the strong reviews. My main complaints come down to two major areas: the excessive use of sample code and the poor choice and grouping of contents. First, many of the major ideas are presented in blocks of sample code. At first, this is good, because the samples are short and you are just seeing the basics. However, this soon becomes a very bad thing. Often, key new pieces are buried in a long sample program, most of which is boilerplate repeated from the previous example. You often have to read through a couple of pages of code to see one small new snippet. To make matters worse, the relevant new sections in the sample code are not highlighted from the surrounding old stuff. And sometimes they only appear in the example code and are not mentioned in the book's text. It is just too hard to see the important parts. Additionally, some of the code examples are almost completely pointless. For example, when talking about method overloading, the book contains about four pages of code with variation after variation of the same 1-line function just varying the type being passed in. This is silly. Showing every single permutation is ridiculous! Plus, the book never includes the output of any of these programs. Often, the whole point of the example cannot be determined without looking at the output, and the book doesn't reproduce that, nor does it explicitly state the point of the example. The second problem area is the organization of material. There is a lot to cover and it makes sense to defer less important details. Unfortunately, the book just throws in tons of junk! For example, in the 85 page I/O chapter, the book makes diversions into gzipped I/O streams and string tokenizing. Now these may be useful utilities, but there are so many basic elements to cover, I really wished the chapter stuck to the core. Ironically, in the next chapter on Class objects and RTTI. The author glosses over almost all of the details (except for a few you can glean only by reading the code snippets). I'd rather defer the stream tokenization until later and have a page or two of explicit description of Class objects. Argh! Then we get to the Windows and Applets chapter which begins to describe JFC and Swing and various widgets and layout schemes, and manages to go the entire chapter without a single picture or diagram of what to expect! I found this book to be frustrating, not explicit enough for a programming book, and not organized well for an introduction to Java.
| 
