Java Code Optimization Details and Best Practices

Code optimization aims to prevent unknown errors in production by addressing issues early in development, reducing downtime caused by bug fixes and restarts.

The main goals are to shrink code size and boost runtime efficiency.

Optimization Details

1. Use final modifiers for classes and methods – final classes cannot be subclassed and final methods can be inlined, potentially improving performance by up to 50%.

2. Reuse objects – Prefer StringBuilder / StringBuffer over string concatenation to avoid excessive object creation and garbage collection.

3. Prefer local variables – Local variables reside on the stack and are faster than static or instance fields.

4. Close streams promptly – Release I/O and database resources as soon as they are no longer needed.

5. Avoid repeated calculations in loops for (int i = 0; i < list.size(); i++) { ... } Replace with:

for (int i = 0, length = list.size(); i < length; i++) { ... }

6. Lazy loading – Create objects only when required. if (i == 1) { list.add(str); } Change to:

if (i == 1) { String str = "aaa"; list.add(str); }

7. Use exceptions sparingly – Throwing an exception incurs stack trace generation and object creation.

8. Place try‑catch outside loops – Reduces the overhead of handling exceptions inside frequently executed code.

9. Set initial capacity for array‑based collections – For ArrayList , StringBuilder , etc., specify an appropriate initial size to avoid repeated resizing.

10. Use System.arraycopy() for bulk copying

11. Replace arithmetic with bit shifts when possible

for (int val = 0; val < 100000; val += 5) {
    a = val * 8;
    b = val / 2;
}

becomes

for (int val = 0; val < 100000; val += 5) {
    a = val << 3;
    b = val >> 1;
}

12. Avoid creating objects inside loops

for (int i = 1; i <= count; i++) {
    Object obj = new Object();
}

Instead reuse a single reference.

13. Prefer arrays over ArrayList when size is known

14. Prefer HashMap , ArrayList , StringBuilder over synchronized alternatives

15. Do not declare public static final arrays – The reference is immutable but the contents can still be modified.

16. Use singletons judiciously – Control resource usage, instance creation, and data sharing.

17. Avoid unnecessary static variables – Static references prevent garbage collection.

18. Invalidate unused HTTP sessions

19. Iterate RandomAccess collections with indexed for‑loops

20. Prefer synchronized blocks to synchronized methods

21. Declare constants as static final with uppercase names

22. Remove unused objects and imports

23. Minimize reflection usage in performance‑critical code

24. Use connection pools and thread pools

25. Use buffered I/O streams

26. Choose ArrayList for random access and LinkedList for frequent insertions/removals

27. Limit the number of method parameters

28. Write constant first in equals checks to avoid NPE

29. Prefer if (i == 1) over if (1 == i) for readability

30. Do not rely on toString() for arrays

31. Avoid unsafe down‑casting of primitive types

32. Remove unused elements from shared collections

33. Convert primitives to strings using toString() or String.valueOf() for best performance

34. Iterate maps via entry set with an iterator for maximum speed

35. Close resources in separate try‑catch blocks to guarantee each close executes

36. Remove ThreadLocal values after use

37. Declare constants with uppercase names to avoid “magic numbers”

38. Use uppercase L for long literals

39. Annotate overridden methods with @Override

40. Use Objects.equals(a, b) to avoid NPE

41. Prefer StringBuilder over + for string concatenation inside loops

42. Avoid catching RuntimeException subclasses when possible

43. Use ThreadLocalRandom instead of shared Random in multithreaded code

44. Make constructors of utility, singleton, and factory classes private

These practices collectively reduce memory consumption, improve runtime speed, and make Java applications more reliable and maintainable.