30 Essential Java Code Optimization Tips to Boost Performance and Prevent Bugs

The author shares practical Java code‑optimization experiences gathered from work and study, emphasizing that optimization not only improves performance but, more importantly, helps avoid unknown runtime errors.

1. Code Optimization Goals

Reduce code size.

Improve code execution efficiency.

2. Code Optimization Details

Prefer final modifiers for classes and methods. Final classes cannot be subclassed and final methods can be inlined, potentially increasing performance by up to 50%.

Reuse objects, especially String objects. Use StringBuilder / StringBuffer for concatenation to avoid excessive object creation and garbage collection.

Use local variables whenever possible. Stack‑allocated variables are faster and automatically reclaimed.

Close streams promptly. Release resources after database or I/O operations to prevent heavy system overhead.

Avoid repeated calculations of variables. Cache results instead of recomputing, e.g., replace repeated list.size() calls with a stored variable.

Apply lazy loading. Create objects only when needed, as illustrated by the before/after images.

Use exceptions sparingly. Throwing an exception creates a new object and stack trace, which is costly; exceptions should signal errors, not control flow.

Place try‑catch outside loops. This reduces overhead inside the loop body.

Pre‑size collections and utilities. Specify initial capacities for ArrayList, StringBuilder, HashMap, etc., to avoid costly resizing.

Use System.arraycopy() for bulk copying.

Replace multiplication/division with bit‑shift operations when appropriate. Bit‑shifts are faster but should be documented for readability.

Avoid creating objects inside loops. Reuse a single reference instead of repeatedly instantiating objects.

Prefer arrays over ArrayList when size is known.

Prefer HashMap , ArrayList , StringBuilder over synchronized alternatives.

Do not declare arrays as public static final . This does not prevent modification of the array contents and can introduce security risks.

Use singletons judiciously. They reduce load time and resource usage when appropriate.

Limit the number of method parameters. Too many parameters violate object‑oriented principles and increase error risk.

Write constant strings on the left side of equals checks. This prevents NullPointerException.

Prefer i == 1 over 1 == i for readability.

Avoid calling toString() on arrays. Use collections' toString() instead.

Do not down‑cast primitive types beyond their range. This yields incorrect values.

Remove unused data from shared collections. Prevent memory leaks by cleaning up stale entries.

Convert primitive types to strings using toString() first, then String.valueOf() , and avoid concatenation with + as the slowest method.

Iterate Map efficiently. Use entry set iteration for best performance; use keySet() when only keys are needed.

Close resources separately. Ensure each resource is closed even if another close throws an exception.

Remove ThreadLocal values after use. Prevent stale data from being reused by pooled threads.

Replace magic numbers with named constants.

Use uppercase L for long literals.

Annotate overridden methods with @Override .

Prefer Objects.equals() for null‑safe comparisons.

Use StringBuilder for string concatenation inside loops.

Avoid catching runtime exceptions that can be prevented. Validate inputs to prevent ArithmeticException, NullPointerException, etc.

Prefer ThreadLocalRandom over shared Random instances.

Make constructors of static, singleton, and factory classes private.

By paying attention to these small details, developers can significantly improve Java application performance and reliability while reducing the risk of hard‑to‑track bugs.