Introduction

Effective Java (3rd Edition) by Joshua Bloch is the definitive guide to writing correct, efficient, and maintainable Java code. It contains 90 items - each a concise rule distilled from years of experience building the Java platform itself.

What This Book Is About

The book is not intended to be read cover-to-cover. Each item stands on its own and captures a practice generally held to be beneficial by the best and most experienced Java programmers. Items are cross-referenced so you can plot your own course.

Guiding Principles

All rules in this book derive from a handful of fundamental principles:

• Clarity and simplicity are paramount. The user of a component should never be surprised by its behavior.
• Components should be as small as possible but no smaller. (A component is any reusable software element — from a single method to a complex multi-package framework.)
• Code should be reused, not copied.
• Dependencies between components should be minimized.
• Errors should be detected as early as possible — ideally at compile time.

New Features Coverage (3rd Edition)

The third edition was updated for Java 9. Key new features and where they're covered:

Feature	Items	Java Release
Lambdas	Items 42–44	Java 8
Streams	Items 45–48	Java 8
Optionals	Item 55	Java 8
Default methods in interfaces	Item 21	Java 8
try-with-resources	Item 9	Java 7
@SafeVarargs	Item 32	Java 7
Modules	Item 15	Java 9

How to Use This Knowledge Base

This knowledge base mirrors the 12 chapters of the book. Each chapter covers one broad aspect of software design:

1. Creating and Destroying Objects — factory methods, builders, singletons, GC hints
2. Methods Common to All Objects — equals, hashCode, toString, clone, Comparable
3. Classes and Interfaces — accessibility, immutability, composition vs. inheritance
4. Generics — raw types, wildcards, type safety
5. Enums and Annotations — replacing int constants, annotation processors
6. Lambdas and Streams — functional programming in Java
7. Methods — parameter validation, defensive copying, API design
8. General Programming — variables, loops, libraries, primitives, strings
9. Exceptions — checked vs. unchecked, failure atomicity
10. Concurrency — synchronization, executors, thread safety
11. Serialization — alternatives, proxies, security

💡 Tip for Spring developers: Pay special attention to Items 5 (dependency injection), 17 (immutability), 42–48 (lambdas/streams), and 78–84 (concurrency) — these are the most impactful for modern Spring application development.

Quick Navigation

• Browse all items: Items Index
• Start chapter flow: Chapter 2 - Creating and Destroying Objects
• Switch book: Clean Code Introduction
• Switch book: DDIA Introduction