Module 11: Java 8 Best Practices & Anti-Patterns

Phase

Phase 4 – Expert Level

Target Audience

• Developers using Java 8 in production
• Senior Java developers and tech leads
• Anyone preparing for advanced interviews or code reviews

---

1. Objective of This Module

By the end of this module, you will:

• Know when to use and when NOT to use Java 8 features
• Identify common Java 8 anti-patterns
• Write readable, maintainable, production-ready code
• Review Java 8 code like a senior engineer

---

2. Streams vs Loops – Choosing the Right Tool

Prefer Streams When:

• Transforming data
• Filtering or mapping collections
• Building pipelines

Prefer Loops When:

• Logic is complex or highly conditional
• Performance is extremely critical and measured
• Early exits are required

❗ Streams are not a replacement for all loops.

---

3. Overusing Streams (Anti-Pattern)

❌ Bad:

list.stream().forEach(e -> {
    if(e.isValid()) {
        process(e);
    }
});

✔ Better:

for(Element e : list) {
    if(e.isValid()) {
        process(e);
    }
}

Streams should express what, not how.

---

4. Misusing forEach

• forEach is a terminal operation
• Avoid using it for business logic
• Avoid side effects

❌ Bad:

list.stream().forEach(e -> total += e.getValue());

✔ Good:

int total = list.stream()
                .mapToInt(Element::getValue)
                .sum();

---

5. Readability Over Cleverness

❌ Clever but unreadable:

data.stream().map(a -> a.getB().getC().getD()).toList();

✔ Readable:

data.stream()
    .map(A::getB)
    .map(B::getC)
    .map(C::getD)
    .toList();

---

6. Optional Best Practices

✔ Use Optional as return type
❌ Do not use Optional for fields or parameters
❌ Avoid Optional.get()

return Optional.ofNullable(user);

---

7. Parallel Streams – Handle with Care

• Default to sequential streams
• Use parallel streams only after testing
• Never use with IO operations

Parallel ≠ Faster

---

8. Debugging Streams

Tips:

• Break long pipelines
• Use peek() only for debugging
• Log intermediate results carefully

stream.peek(System.out::println);

⚠️ Remove peek() in production code.

---

9. Common Java 8 Anti-Patterns

• Massive stream pipelines
• Modifying external variables
• Mixing imperative and functional styles badly
• Using Optional everywhere

---

10. Code Review Checklist

Ask:

• Is the stream readable?
• Are there side effects?
• Is Optional used correctly?
• Is parallelism justified?

---

11. Hands-On Exercises

Exercise 1

Refactor bad stream code to readable code.

Exercise 2

Replace unnecessary streams with loops.

Exercise 3

Identify anti-patterns in a given code snippet.

---

12. Summary

• Java 8 is powerful but easy to misuse
• Best practices matter more than features
• Senior developers focus on readability and safety

---

13. What’s Next?

➡️ Module 12: Java 8 in Real Projects (Spring Boot Focus)