Effective Java (2nd Edition)

Everyone should read this after learning the basics of Java.

Once you have learned the language constructions, you have the tools, but do not know how to use them. This book shows the right way to use many of such tools.

This book is simply amazing. Gives you tons of good advices, recomendations and more to improve your java design and code. I use this book as reference one, when I need to develop something, first read related chapters of this book and then write code.

Only one drawback, there are few code. Wil be better to have more code examples related with some topics.

I had been waiting for the second edition for almost a year and finally it's in my hand. I must say that all the wait was worth it since Josh has done an amazing job once again. If you are a java programmer this is a MUST have book. If you can only afford to buy one and only one java book, you should buy this book and you won't regret your decision. Thank you Joshua Bloch for teaching me how to write better code on a day to day basis.

The content is good, exactly as I expected. But the book is very poorly printed. The cover looks like it is larger than the original size so it is pretty blurry. The pages look like they are printed at original scale but because of the larger page size there's a really big margin. Overall poor quality of the physical book.

This is a must for all java engineers. Teaches really good best practices that a lot of people don't know or forget to do. If you code in java and have not read this book you are doing yourself injustice.

The second edition of "Effective Java" is almost like a completely different book from the first. There were new chapters addressing Java 5 topics such as generics, enums and autoboxing. Existing patterns were rewritten for Java 5/6 - both conceptually and for the code examples. For example, overloading now address varargs. The number of items grew from 57 to 78 as well and the author removed the old ones that are obsolete.

As a reference, chapter one provided a table to quickly find items on Java 5. The appendix provided a cross mapping to find items from the first edition in this copy.

For those new to "Effective Java", it is meant for intermediate to advanced Java developers. It provides best practices, recipes and idioms for working with Java. The author is good about listing both advantages and disadvantages to choose when to apply a tip.

When thinking about my favorite chapter, I have trouble picking just one. I'm torn between the concurrency and enum chapters. The book goes beyond the common "use enums over constants" and goes into things like EnumBitSets.

I learned a lot reading the first edition of this book and learned just as much reading the second. If you have the first edition, but this one anyway. And if you haven't read the first edition, get your hands on the latest copy!

This book has surprised me so many times, starting with the fact that it's not really a Java language book. Instead, if teaches best practices and caveats on how to apply the language. This isn't my first technical book in the field, and the book still made me gasp a few times. I absolutely love it and would recommend it to anyone who starts working with the language. Very easy to read -- great writing style, and the formatting is unusually clear for a technical book -- the author has put in a lot of effort and it shows.

Did you realize that enums can implement interfaces? That the simplest safe way to implement a singleton is using an enum? That it's possible to obtain an object reference to a private member using serialization? There are lots of ways to learn the language basics and figure out how to use the libraries. But nowhere do you have such a dense collection of non-obvious, yet important issues that any Java developer ought to be aware of. The book is written from the perspective of someone who creates public APIs, so there is a lot of obsessing over how to prevent users from doing things they shouldn't (intentionally, or not). But even if that's not a big concern for you, it's nevertheless important to be aware of the issues. Having read the first edition a while back, reading the second edition was more that a good refresher -- it's almost a different book. This is in part thanks to Java 5, which has made a lot of the original items (e.g. how create enumerations) obsolete, while introducing the need for a whole new set of items (e.g. regarding the use of generics).

Original review written by Lauro Canonica, JUG Lugano, [...]

I have many years of Java development behind me so when people recommended this book I thought: Uff, one more book about Java. How is it possible to write an interesting book after all the already existing Java books? Then I started reading random sections and I had to change my mind. The book is written for experienced Java developers. It won't explain the basics of programming in Java (nothing for newbies) but it concerns itself with the real issues of developers.

The book is divided in 78 items and, for every topic, it comes with clear explanations and recommended solutions. The explanations are mostly concise and to the point (only a few times did I have to skip some pages of, in my opinion, theoretical discussions).
This book is actually a second edition (revised for Java 6) and was started for Java 5. So particular attention is given to the new features of Java 5 such as Generics, Autoboxing, Enums and Annotations.

If you are wondering if you should read the book just check if you know the answer to the following simple questions.
* What are the advantages of a static factory over a constructor?
* What's wrong with the statement String s= new String("hello"); ?
* What are the dangers of Autoboxing?
* What are the dangers of overriding equals?
* How do I eliminate unchecked warnings?
* When are Lists better than Arrays?
* What's the problem with float and double?
* Why is implementing serializable a delicate issue?

If you know all the answers then you still might want to read it for a clear and precise explanation.

The fact that the book doesn't have to be read from cover to cover following a strict order makes it a book that you can pick when you have 10 minutes to spare and just read one item at the time. That's, at least, how I read it and it improved or reassured my knowledge of the Java Language.

So I'm recommending the book and I say: Good job Joshua!