This book seems to be one of the most critically acclaimed Java titles. What could I possibly add to what has been said? The acclaim is fully deserved. I had the feeling that I already learned something new and important as soon as I reached page twenty. This is something that I cannot say of very many books. Effective Java manages to be extremely useful and simultaneously extremely easy to read. However, "easy" doesn't mean simple in this case, since many of the discussed problems are subtly complex. Some are so complex, in fact, that Java beginners might not fully understand or appreciate them. So, it's probably not a book for beginners. On the other hand, the book is neither esoteric. The 78 items are general Java programming issues which one is likely to encounter in everyday work at some point, regardless of any specific domain. The book is written in a clear and concise language and each problem is exceptionally well reasoned. The author has a very deep understanding of the Java language, which is rather apparent and no surprise, since Joshua Bloch is one of the architects of the Java platform. Incidentally, this also means that the problems are discussed from the perspective of an API designer rather than from the perspective of an application programmer. This is useful, because it is primarily concerned with creating robust and high quality interfaces. Architects, designers, and application programmers benefit likewise from this. The items discussed in this book can probably be described as design and implementation level rationales. They are grouped by Java categories, such as generics, enums, annotations, exceptions, serialisation, as well as by more general concepts, such as object creation, classes and interfaces, methods and concurrency. Many of the individual topics are related; therefore the author makes ample use of cross references, which is helpful for reference use. The included code examples are a joy to read; they are clear, concise, and always illustrative. While discussing the intricacies of the above named topics, Joshua Bloch casually introduces the reader to a good number of commonly used design patterns, many of which are illustrated with code examples. However, design patterns are not themselves formally discussed. The book equips Java programmers with an arsenal of relevant best practices, from comparatively simple things such as creating objects, implementing "equals()" and "hashCode()" methods to more advanced topics, such as concurrency, mutability, and thread safety. In doing so, Joshua Bloch points out quite a few quirks and peculiarities of the Java language, and he does not only point them out, but explains their practical consequences in detail. Thus, the book has great didactic value, as the reader will end up with a higher level of familiarity with the language. Reading this book is time well invested for any Java programmer.

This book is one of the highest rated Java books in existence. The main reason that I chose to read this book is because one of my colleagues highly recommended it. Needless to say, I have to jump on the bandwagon and join in with all of the hoopla and praise that’s associated with this book. It is simply fantastic on several latitudes. This includes but is not limited to the scope, depth, and writing style of this piece of work . The concepts are presented in bite-sized items which often cross reference one another. These chunks are then grouped into chapters for broader topics such as “Generics”, “Exceptions” and “Enums and Annotations” just to name a few. All items are presented in a practical manner that will help real developers on the job immediately. You’ll go to work the next day and be able to quickly identify code that should be improved by applying the principles in this book. Included code samples are clear, concise and contain comments that highlight the relevant parts of the code. Every item is gold and the constant supply will have you reading it from cover to cover with little interruption.

It should be of no surprise that this book is not for beginners. In fact, I would argue that it’s targeted to advanced Java developers looking to obtain “Expert” status. (“Guru” status come after one reads both the Java and JVM specifications in their entirety and grow a worthy beard). If you’re a curious Java developer looking for some of the more interesting aspects of the language or a Java veteran determined to take your understanding to the next level, Effective Java is the book you need to have.

I am thoroughly enjoying this book and learning a lot in the process. The author is responsible for many of the successful APIs in the Java language, such as the Collections framework, so he certainly knows what he is talking about.

I am still a student but I can relate to some of the things he talks about, and see where I have deviated from his suggestions in the past. The author is clear to point out why these things are problems in terms of either code reuse, extensibility, type safety, or some other aspect, so even though it wasn't necessarily an issue in the context of a school project, in the real world it certainly might be.

The author borrows the format from Scott Meyer's Effective C++ series of books, and it works very well in this context. While the chapters are logically organized, they are set up in such a way that you do not need to read from start to finish; you can jump around and read the interesting bits at will, and often items in one section of the book refer to later (or earlier) items.

Finally, I appreciate that the book explains some of the less well known or understood features of recent versions of Java. For instance, I had never heard of the annotation feature added, but he goes on to show a great example of how you can use annotations to build a simple test framework for a class.

Even if you are not yet a software professional, you owe it to yourself to get a jump start by reading this book.

I'll start this review telling you what this book is not:

- This is not a cookbook. You will not find template solutions to regular programming problems here.

- This is not a "fun" book. This is not like the Head First books where they have lots of funny stuff to keep you entertained.

- This is not a book for beginners. If you are just starting to learn programming, this will only leave your mind in a very confused state.

- This is not "just a Java book". Although most of the topics described in this book are tightly related to Java's mechanics and implementation details, it has a lot of great teachings that are language agnostic.

That being said, this book is a very deep analysis on many diverse topics, most of them centered on Java's mechanics, language features and most prominent flaws. You can expect, for example, lost of pages explaining how to correctly implement a serializable class or how to clone an object correctly. But you will not only get answers here. Most topics include a very throughout explanation on the logic behind the solutions and the potential pitfalls and risks of failing to follow the suggestions described and even counter-intuitive problems derived from design flaws in the Java language.

I will admit that many of the topics of the books have no practical use unless you have to implement a low level solution from scratch or you are working on a very important project where a design flaw might cause catastrophic failure. Still, I guarantee that anyone who reads this book will find something useful.

I can honestly say that this book has improved my programming skill tremendously. It is divided to short items, each one packs a powerful wisdom. My boss at the startup I was working at gave me his copy and I read just one item each morning before starting my day, now almost 3 years later I bought my own copy and I'm reading it again. it's amazing that I can still learn in the 2nd read, now that I have more experience.

Josh Bloch is just amazing, there are a lot of Java books out there, except this one was written by the same guy who designed and wrote most of the standard library.

If you apply Bloch's lessons, your code will be cleaner, safer, more readable, efficient and will lead to fewer bugs. guaranteed.

The book is well written, explained using solid engineering concepts which you can pass on to your teammates,

and covers a wide range of topics which anyone can benefit from.

I recommended this book to all of my engineer friends, and they all have it now and love it.

A must have in every Java developer's belt.

Very good book covering topics of core importance but much beyond the basics. Format could be a little more clear. It kinda reads like a story not a reference, however the information is very good. This is not the type of book that fills pages with reprints of javadocs or elaborates upon basic concepts with dumb examples exhaustively typed out. It is suited to the person who can already develop code at a professional level looking to become more effective with the Java language. These are the types of things developers share with each other during code reviews. I found myself incorporating ideas from the book into my coding style almost immediately. The information is useful and worth knowing. Great for anyone mid-level and up.

This is the book I wish I had when I was working as a Java programmer. Bloch gives 78 ways to write idiomatic Java code, and the book is written in the Scott Myers style where each item can stand on its own.

I liked that the author made definitive statements about which style is best, and explains why. For example Item 16, "Favor composition over inheritance" describes how inheritance can violate encapsulation and why it leads to fragile software. First we are shown an example using inheritance that is broken, a way to rewrite it using composition, and followed by a concluding explanation.

The author highlights key points in bold text; this was a helpful way to see the critical points being made. Many statements are well sourced as the References section in the back contains upwards of 40 books.

I read some other reviews of this book which said they thought the author was too authoritative with his opinion. I actually found this to be the strong suit of the book, in that the author states his design preference, why it is best, shows examples, and the sources his information. He knows the material and the language very well. I have yet to read a better Java design book so far.

Wish all books were like this - OR - rather - All programming languages had a book like this.

This is not a basic / novice level book - but assumes that the reader has already used Java for a number of years.

It is best to read this book slowly absorbing the thoughts / concepts and what the author is conveying. Some of the things could be subtle but - if they are tried out - after reading each article it makes more sense.

The author had written a lot of the core Java libraries while at SUN - and you can see his name in the source files in the JDK. The author has complete clear and crisp understanding of the concepts and lucidly explains the points - with clear small and right examples.

I used to read this book - 1 article a day and then try out the concepts conveyed in the article.

I had read the 1st edition of the book long time back - and it clearly - imprinted in my mind - why hash() function needs to be written and the deficiencies of a bad hash function.

This new edition includes all the new features of the language as incorporated in Java 1.5 other than the concurrency related classes.

Only deficiency of the book, I do wish - it had some more articles about the Concurrency related libraries that were introduced in Java 1.5.

Anyone who would like to know more about the internals of Java - should purchase this book and read it

Una raccolta di item ben organizzata, precisa e ben scritta riguardante un buon numero di problemi che lo sviluppatore Java si ritrova ad affrontare quotidianamente e le relative "best practices" per risolverli al meglio, scritta da uno dei maggiori Guru del linguaggio al mondo.

Suggerimenti a tutto campo, dall'organizzazione di classi e interfacce, pattern, generics, concorrenza e serializzazione: leggendo questo libro si impara molto più di quello che i tutorial Sun o un qualsiasi corso universitario possono insegnare su Java. Insomma: un must-have per tutti coloro che vogliono approfondire l'uso di questo stupendo linguaggio, anche per quelli che credono di sapere già tutto!

Ich spreche für die 2. Edition. Berechtigterweise erscheint das Buch stets in "Java books you must read"-Listen. Es kennt die grundlegenden Neuerungen von Java 5. (Erst die 3. Edition kennt die weitreichenden Spracherweiterungen, die mit Java 8 kamen)

Das Buch behandelt eigentlich nur die Grundlagen der Sprache und nebenbei einige Patterns, geht dabei aber mehr in die Tiefe als man das von normalen Lehrbüchern gewohnt ist. Daher ist das Buch nichts für Anfänger oder Leute mit nur etwas Java-Erfahrung. Die Texte verwenden teils anspruchsvolles Englisch. Oft schafft es der Autor mit minimalen Code-Beispielen maximale Verwirrung beim Leser zu stiften. Zum Teil musste ich mich (z.B. Kapitel zu Concurrency und Serialization) durchquälen.

Fazit: Im Buch stehen viele nützliche, empfehlenswerte Sachen, die allerdings durch wiederholtes Lesen und eventuell zusätzliches Nachprogrammieren erarbeitet werden müssen.

This book has to be one of the best Java books written, the author explains aspects in such great detail that it changes the way you think about programming in Java. Though I would not recommend this book to someone who is new to Java or new to Programming, simply because the book is written assuming you have somewhat good knowledge of Java and understand enough Java programming that you can create programs yourself and I would also not recommend this book to someone looking for information on specific aspects of Java, instead this book simply increases your current knowledge by explaining how things work and how to improve the way you used them.

El libro trata temas avanzados de Java. No es un libro para aprender la sintaxis o gramática de Java, si no el equivalente a sus frases hechas. Se compone de "items" que abordan diferentes situaciones donde ya existen soluciones bien establecidas. Cada solución se presenta con muchos ejemplos de código.

El libro está bien escrito y bien estructuado. Es de gran utilidad para los que quieren pasar de escribir código Java correcto a código Java eficiente.

Ce livre s'adresse aux personnes maitrisant les bases de JAVA (une connaissance du langage, des API de base et des patterns les plus courants, est indispensable). Il donne beaucoup d'astuces permettant de rendre son code plus lisible, plus réutilisable, et surtout plus performant.

En bref, ce livre est un condensé de bonne pratique, dont chaque développeur JAVA intermédiaire ou avancé devrait être conscient.

Je ne suis vraiment pas déçu de mon achat et je le recommande donc fortement.