Effective Java: 51 Essential Practices for Writing Clean, Efficient Java Code

Effective Java is a classic guide for Java developers; adhering to its principles dramatically improves API quality and overall code craftsmanship.

1. Prefer static factory methods over constructors

Examples such as Integer.valueOf("1") and Boolean.valueOf("true") provide better readability, potential performance gains, and higher flexibility.

Advantages

Readable method names

Can avoid object creation

More flexible (can return subclasses)

Readability

Methods like Point.at(x, y) convey intent better than new Point(x, y).

Performance

Static factories can return cached instances, e.g., Boolean.TRUE and Boolean.FALSE.

public final class Boolean implements Serializable, Comparable<Boolean> {
    public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);
    ...
    public static Boolean valueOf(boolean b) { return b ? TRUE : FALSE; }
    public static Boolean valueOf(String s) { return parseBoolean(s) ? TRUE : FALSE; }
}

Flexibility

Factories can return subclasses, as shown by Collections.emptyList().

public class Collections {
    private Collections() {}
    public static final List EMPTY_LIST = new EmptyList<>();
    public static <T> List<T> emptyList() { return (List<T>) EMPTY_LIST; }
    ...
}

2. Use builders when a class has many constructors

Multiple constructors can become unwieldy, especially in Android UI components. A builder centralizes parameter validation and improves readability.

public class AlertDialog {
    private AlertDialog(Builder b) { /* validate */ }
    public static class Builder {
        private int width;
        private int height;
        private String title;
        public Builder setTitle(String t) { this.title = t; return this; }
        ...
        public AlertDialog build() { return new AlertDialog(this); }
    }
}

3. Strengthen singletons with private constructors or enums

Private constructors prevent reflection attacks; enums guarantee a single instance even after serialization.

public class Elvis {
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() {}
}

public enum Elvis { INSTANCE; }

4. Make utility classes non‑instantiable

Declare a private constructor that throws an exception to avoid accidental instantiation.

public class Util {
    private Util() { throw new AssertionError(); }
}

5. Avoid creating unnecessary objects

Reuse objects when possible

Use object pools for expensive resources

Do not pool cheap objects; modern JVMs handle them efficiently

6. Eliminate obsolete object references

Three common memory‑leak sources: self‑managed memory (e.g., shrinking arrays), caches, and listeners/callbacks. Null out references after use.

public Object pop() {
    if (size == 0) throw new EmptyStackException();
    elements[size] = null; // help GC
    return element[--size];
}

7. Do not invoke garbage collection explicitly

Rely on the JVM’s automatic GC; explicit finalizer calls are costly and often unnecessary.

8‑10. Follow the equals/hashCode/toString contract

Reflexive, symmetric, transitive, consistent, non‑null

Always override hashCode when equals is overridden

Provide a meaningful toString implementation

11‑13. Use clone cautiously, implement Comparable when natural ordering makes sense, and minimize member accessibility

Prefer private > protected > package‑private > public to reduce coupling.

14‑18. Prefer interfaces over public fields, use enums instead of int constants, and favor composition over inheritance

Composition (wrapper/decorator) reduces fragile inheritance hierarchies.

19‑23. Use generics, bounded wildcards (PECS), and avoid raw types

public void pushAll(Iterator<? extends E> src) { for (E e : src) push(e); }
public void popAll(Collection<? super E> dst) { while (!isEmpty()) dst.add(pop()); }

24‑30. Prefer EnumSet/EnumMap over bit‑mask flags, avoid string‑based type representations, and use appropriate numeric types

public enum Style { BOLD, ITALIC, UNDERLINE, STRIKETHROUGH }
public void applyStyles(Set<Style> styles) { /* ... */ }
text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));

31‑35. Use enums with explicit fields, avoid ordinal(), and annotate code with @Override

36‑38. Validate method parameters, use protected copies, and avoid exposing mutable internal state

public Period(Date start, Date end) {
    this.start = new Date(start);
    this.end = new Date(end);
    if (this.start.compareTo(this.end) > 0) throw new IllegalArgumentException();
}

39‑43. Return empty collections instead of null, minimize mutable parameters, and prefer var‑args only when appropriate

44‑48. Write Javadoc for all public API, keep variable scope minimal, prefer for‑each loops, and avoid float/double for precise calculations (use BigDecimal)

49‑55. Prefer primitive types over boxed types, avoid using strings for non‑text data, use StringBuilder for heavy concatenation, and limit reflection and JNI usage

56‑58. Follow naming conventions, use checked exceptions for recoverable conditions and runtime exceptions for programming errors, and avoid unnecessary checked exceptions

Overall, the article provides a comprehensive checklist for writing clean, maintainable, and efficient Java code.