move Clippings from thpeetz-notes vault

Clippings/3 Advanced Java Best Practices.md

@@ -0,0 +1,74 @@
+---
+title: "3 Advanced Java Best Practices"
+source: "https://orlandolorenzodeveloper.medium.com/3-advances-java-best-practices-ac7d02a55432"
+author:
+  - "[[Lorenzo Orlando | Kreyzon Custom Software]]"
+published: 2024-10-01
+created: 2024-10-29
+description: "Hello everyone, today we’re diving deep in some advanced Java best practices. Let’s start right away. Java 8 introduced streams and lambda expressions, which allow for cleaner, functional-style code…"
+tags:
+  - "clippings"
+---
+[
+
+![Lorenzo Orlando | Kreyzon Custom Software](https://miro.medium.com/v2/resize:fill:88:88/1*RHRLTs-zRl19nGgDF230og.png)
+
+](https://orlandolorenzodeveloper.medium.com/?source=post_page---byline--ac7d02a55432--------------------------------)
+
+![](https://miro.medium.com/v2/resize:fit:700/1*Ac8yn8qIWLfRfS8JeIY_pw.png)
+
+Hello everyone, today we’re diving deep in some advanced Java best practices. Let’s start right away.
+
+## 1\. Use Streams and Lambda Expressions Efficiently
+
+**Why?**
+
+Java 8 introduced streams and lambda expressions, which allow for cleaner, functional-style code. While they are powerful, improper use can lead to performance overhead and complexity.
+
+**Best Practices:**
+
+- Avoid creating multiple intermediate Stream operations like `filter()` and `map()` if not necessary, as they can add overhead.
+- Leverage **parallel streams** for CPU-bound tasks but avoid them for I/O-bound tasks (due to context switching).
+- Prefer `**forEach()**` for side effects like logging, but use terminal operations like `collect()` for transforming data.
+
+**Example**
+
+```
+List<String> names = employees.stream()                              .filter(e -> e.getAge() > 30)                              .map(Employee::getName)                              .collect(Collectors.toList());
+```
+
+## 2\. Minimize Synchronization and Leverage Concurrency Utilities
+
+**Why?**
+
+Java provides a rich set of concurrency utilities like `ExecutorService`, `ForkJoinPool`, and `CompletableFuture`. Using these properly avoids blocking and bottlenecks in multi-threaded applications.
+
+**Best Practices:**
+
+- Use `**ConcurrentHashMap**` over synchronized collections for thread-safe operations with better performance.
+- Utilize **optimistic locking** (e.g., `java.util.concurrent.atomic` package) instead of traditional `synchronized` blocks.
+- Leverage **non-blocking algorithms** and modern concurrency utilities like `CompletableFuture` for asynchronous processing.
+
+**Example**
+
+```
+CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {    processData();}, executorService);
+```
+
+## 3\. Apply Design Patterns and Immutability Smartly
+
+**Why?**
+
+Design patterns like **Singleton**, **Factory**, and **Builder** ensure better object management, while immutability improves thread-safety and reduces side effects.
+
+**Best Practices:**
+
+- Ensure **immutability** in frequently used objects to make them thread-safe without requiring synchronization.
+- Use **Factory Pattern** to encapsulate object creation, making the code more flexible and testable.
+- Apply the **Builder Pattern** for constructing complex objects, making the code cleaner and avoiding telescoping constructors.
+
+**Example**
+
+```
+public class User {    private final String name;    private final int age;    private User(Builder builder) {        this.name = builder.name;        this.age = builder.age;    }    public static class Builder {        private String name;        private int age;        public Builder withName(String name) {            this.name = name;            return this;        }        public Builder withAge(int age) {            this.age = age;            return this;        }        public User build() {            return new User(this);        }    }}User user = new User.Builder().withName("John").withAge(25).build();
+```