[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":88,"_72":89,"_35":90},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":16,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71},"id",12,"title","Functional Programming Patterns","slug","clean-code-part-11-functional","excerpt","Explore pure functions, immutability, stream patterns, and higher-order functions to make code more readable, testable, and thread-safe.","# Advanced Clean Code Patterns Part 11: Functional Clean Code\n\nFunctional programming concepts have transformed how we write clean Java code. This article covers pure functions, immutability, stream patterns, and how to apply functional thinking to make your code more readable, testable, and maintainable.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Concepts | Pure Functions, Immutability, Higher-Order Functions |\n| Java Features | Streams, Optional, Lambdas, Method References |\n| Benefits | Easier testing, no side effects, thread safety |\n| Trade-offs | Learning curve, occasional performance overhead |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Pure functions** and why they matter\n- **Immutability** patterns for safer code\n- **Stream patterns** for clean data transformations\n- **Higher-order functions** for reusable logic\n- **When to go functional** vs imperative\n\n---\n\n## Production Story: The Side Effect Bug\n\nA payment reconciliation service had a bug that took weeks to find:\n\n```java\n// ❌ Hidden side effect caused intermittent failures\npublic class PaymentReconciler {\n private BigDecimal runningTotal = BigDecimal.ZERO; // Shared state!\n\n public ReconciliationResult reconcile(List payments) {\n List matched = new ArrayList<>();\n\n for (Payment payment : payments) {\n if (matchesTransaction(payment)) {\n matched.add(payment);\n runningTotal = runningTotal.add(payment.getAmount()); // Side effect!\n }\n }\n\n return new ReconciliationResult(matched, runningTotal);\n }\n}\n```\n\n**The bug:** When called from multiple threads or called twice, `runningTotal` accumulated incorrectly.\n\n**The fix:** Pure functions with no shared state:\n\n```java\n// ✅ Pure function - no side effects\npublic class PaymentReconciler {\n\n public ReconciliationResult reconcile(List payments) {\n List matched = payments.stream()\n .filter(this::matchesTransaction)\n .toList();\n\n BigDecimal total = matched.stream()\n .map(Payment::getAmount)\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n\n return new ReconciliationResult(matched, total);\n }\n}\n```\n\n---\n\n## Mental Model: Pure vs Impure Functions\n\n```text\n┌─────────────────────────────────────────────────────────────────┐\n│ PURE VS IMPURE FUNCTIONS │\n├─────────────────────────────────────────────────────────────────┤\n│ │\n│ PURE FUNCTION │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Input ──────→ [Function] ──────→ Output │ │\n│ │ │ │\n│ │ • Same input ALWAYS produces same output │ │\n│ │ • No side effects (doesn't change external state) │ │\n│ │ • Doesn't depend on external state │ │\n│ │ │ │\n│ │ Example: int add(int a, int b) { return a + b; } │ │\n│ │ │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n│ IMPURE FUNCTION │\n│ ┌────────────────────────────────────────────────────────────┐ │\n│ │ ┌──────────┐ │ │\n│ │ │ Database │ │ │\n│ │ └────┬─────┘ │ │\n│ │ │ read/write │ │\n│ │ Input ──────→ [Function] ──────→ Output │ │\n│ │ │ │ │\n│ │ ┌────┴─────┐ │ │\n│ │ │ Logger │ │ │\n│ │ └──────────┘ │ │\n│ │ │ │\n│ │ • Output may vary (depends on DB state) │ │\n│ │ • Side effects (writes to DB, logs) │ │\n│ │ • Harder to test, harder to reason about │ │\n│ │ │ │\n│ └────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Pure Functions\n\n```java\n// ❌ Impure - depends on external state\npublic class PriceCalculator {\n private double taxRate; // External state\n\n public void setTaxRate(double rate) {\n this.taxRate = rate;\n }\n\n public double calculate(double price) {\n return price * (1 + taxRate); // Result depends on taxRate\n }\n}\n\n// ✅ Pure - all inputs explicit\npublic class PriceCalculator {\n\n public double calculate(double price, double taxRate) {\n return price * (1 + taxRate);\n }\n\n // Or use a value object\n public Money calculate(Money price, TaxRate rate) {\n return price.multiply(rate.asMultiplier());\n }\n}\n```\n\n**Benefits of pure functions:**\n- Testable: No mocking required\n- Cacheable: Same input = same output (memoization)\n- Thread-safe: No shared mutable state\n- Composable: Can chain without side effects\n\n```java\n// ✅ Pure function composition\npublic class OrderProcessor {\n\n public OrderSummary process(Order order) {\n return calculateSubtotal(order)\n .andThen(this::applyDiscounts)\n .andThen(this::calculateTax)\n .andThen(this::calculateShipping)\n .apply(order);\n }\n\n // Each function is pure\n private Function calculateSubtotal(Order order) {\n BigDecimal subtotal = order.getItems().stream()\n .map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n return PricedOrder.from(order, subtotal);\n }\n}\n```\n\n---\n\n### Pattern 2: Immutability\n\n```java\n// ❌ Mutable - can be changed after creation\npublic class User {\n private String name;\n private String email;\n private List roles;\n\n public void setName(String name) { this.name = name; }\n public void setEmail(String email) { this.email = email; }\n public List getRoles() { return roles; } // Mutable list exposed!\n}\n\n// ✅ Immutable - safe to share\npublic final class User {\n private final String name;\n private final String email;\n private final List roles;\n\n public User(String name, String email, List roles) {\n this.name = Objects.requireNonNull(name);\n this.email = Objects.requireNonNull(email);\n this.roles = List.copyOf(roles); // Defensive copy\n }\n\n public String name() { return name; }\n public String email() { return email; }\n public List roles() { return roles; } // Already immutable\n\n // \"Setter\" returns new instance\n public User withEmail(String newEmail) {\n return new User(this.name, newEmail, this.roles);\n }\n\n public User addRole(Role role) {\n List newRoles = new ArrayList<>(this.roles);\n newRoles.add(role);\n return new User(this.name, this.email, newRoles);\n }\n}\n\n// ✅ Even better - use Records (Java 16+)\npublic record User(String name, String email, List roles) {\n public User {\n Objects.requireNonNull(name);\n Objects.requireNonNull(email);\n roles = List.copyOf(roles); // Defensive copy in compact constructor\n }\n\n public User withEmail(String newEmail) {\n return new User(name, newEmail, roles);\n }\n}\n```\n\n**Immutable collections:**\n\n```java\n// ✅ Immutable collection patterns\n\n// Creation\nList immutable = List.of(\"a\", \"b\", \"c\");\nSet immutableSet = Set.of(1, 2, 3);\nMap immutableMap = Map.of(\"one\", 1, \"two\", 2);\n\n// From existing (defensive copy)\nList copy = List.copyOf(existingList);\n\n// Building immutable from stream\nList orders = orderStream\n .filter(Order::isActive)\n .toList(); // Returns immutable list (Java 16+)\n\n// Collector for older Java\nList orders = orderStream\n .filter(Order::isActive)\n .collect(Collectors.toUnmodifiableList());\n```\n\n---\n\n### Pattern 3: Stream Patterns\n\n```java\n// ✅ Clean stream transformations\n\npublic class OrderAnalytics {\n\n // Transform and aggregate\n public BigDecimal calculateTotalRevenue(List orders) {\n return orders.stream()\n .filter(Order::isCompleted)\n .map(Order::getTotal)\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n }\n\n // Group and summarize\n public Map revenueByCategory(List orders) {\n return orders.stream()\n .filter(Order::isCompleted)\n .flatMap(order -> order.getItems().stream())\n .collect(Collectors.groupingBy(\n OrderItem::getCategory,\n Collectors.mapping(\n OrderItem::getTotal,\n Collectors.reducing(BigDecimal.ZERO, BigDecimal::add))));\n }\n\n // Find with Optional\n public Optional findHighestValueOrder(List orders) {\n return orders.stream()\n .filter(Order::isCompleted)\n .max(Comparator.comparing(Order::getTotal));\n }\n\n // Partition\n public Map> partitionByValue(\n List orders,\n BigDecimal threshold) {\n return orders.stream()\n .collect(Collectors.partitioningBy(\n order -> order.getTotal().compareTo(threshold) > 0));\n }\n}\n```\n\n**Stream vs Loop - when to use which:**\n\n```java\n// ✅ Stream - transformation/aggregation\nList emails = users.stream()\n .filter(User::isActive)\n .map(User::getEmail)\n .toList();\n\n// ✅ Loop - complex control flow, early exit, multiple variables\npublic User findFirstMatch(List users, Predicate criteria) {\n User lastChecked = null;\n for (User user : users) {\n lastChecked = user;\n if (criteria.test(user)) {\n auditLog.record(\"Found match: \" + user.getId());\n return user; // Early exit with side effect\n }\n }\n auditLog.record(\"No match found, last checked: \" + lastChecked);\n return null;\n}\n```\n\n---\n\n### Pattern 4: Higher-Order Functions\n\n```java\n// ✅ Functions that take/return functions\n\npublic class ValidationService {\n\n // Function that returns a function\n public Predicate minLength(int min) {\n return s -> s != null && s.length() >= min;\n }\n\n public Predicate maxLength(int max) {\n return s -> s != null && s.length() <= max;\n }\n\n public Predicate matches(String regex) {\n Pattern pattern = Pattern.compile(regex);\n return s -> s != null && pattern.matcher(s).matches();\n }\n\n // Compose predicates\n public Predicate emailValidator() {\n return minLength(5)\n .and(maxLength(255))\n .and(matches(\"^[\\\\w.+-]+@[\\\\w.-]+\\\\.[a-z]{2,}$\"));\n }\n}\n\n// ✅ Higher-order function for cross-cutting concerns\npublic class ServiceWrapper {\n\n public T withTiming(String operationName, Supplier operation) {\n long start = System.currentTimeMillis();\n try {\n return operation.get();\n } finally {\n long elapsed = System.currentTimeMillis() - start;\n log.info(\"{} took {}ms\", operationName, elapsed);\n }\n }\n\n public T withRetry(int maxAttempts, Supplier operation) {\n Exception lastException = null;\n for (int attempt = 1; attempt <= maxAttempts; attempt++) {\n try {\n return operation.get();\n } catch (Exception e) {\n lastException = e;\n log.warn(\"Attempt {} failed: {}\", attempt, e.getMessage());\n }\n }\n throw new RuntimeException(\"All attempts failed\", lastException);\n }\n\n public T withTransaction(Supplier operation) {\n transactionManager.begin();\n try {\n T result = operation.get();\n transactionManager.commit();\n return result;\n } catch (Exception e) {\n transactionManager.rollback();\n throw e;\n }\n }\n}\n\n// Usage - compose behaviors\nString result = wrapper.withTiming(\"fetchData\",\n () -> wrapper.withRetry(3,\n () -> wrapper.withTransaction(\n () -> repository.fetchData())));\n```\n\n---\n\n### Pattern 5: Optional Patterns\n\n```java\n// ✅ Clean Optional usage\n\npublic class UserService {\n\n // Return Optional for \"might not exist\"\n public Optional findById(Long id) {\n return userRepository.findById(id);\n }\n\n // Chain transformations\n public Optional getUserEmailDomain(Long userId) {\n return findById(userId)\n .map(User::getEmail)\n .filter(email -> email.contains(\"@\"))\n .map(email -> email.substring(email.indexOf(\"@\") + 1));\n }\n\n // Provide defaults\n public User getOrCreateGuest(Long userId) {\n return findById(userId)\n .orElseGet(this::createGuestUser);\n }\n\n // Throw on missing\n public User getRequired(Long userId) {\n return findById(userId)\n .orElseThrow(() -> new UserNotFoundException(userId));\n }\n\n // Conditional execution\n public void notifyIfPresent(Long userId, String message) {\n findById(userId)\n .ifPresent(user -> notificationService.send(user, message));\n }\n\n // Java 9+ ifPresentOrElse\n public void handleUser(Long userId) {\n findById(userId).ifPresentOrElse(\n user -> process(user),\n () -> log.warn(\"User not found: {}\", userId));\n }\n\n // Java 9+ or() for fallback chain\n public User findBestMatch(Long primaryId, Long secondaryId) {\n return findById(primaryId)\n .or(() -> findById(secondaryId))\n .or(this::findDefaultUser)\n .orElseThrow(() -> new NoUserAvailableException());\n }\n}\n```\n\n---\n\n### Pattern 6: Functional Pipeline\n\n```java\n// ✅ Processing pipeline with functions\n\npublic class DataPipeline {\n private final List> steps = new ArrayList<>();\n\n public DataPipeline addStep(Function step) {\n steps.add(step);\n return this;\n }\n\n public T process(T input) {\n T result = input;\n for (Function step : steps) {\n result = step.apply(result);\n }\n return result;\n }\n\n // Or using reduce\n public T processWithReduce(T input) {\n return steps.stream()\n .reduce(Function.identity(), Function::andThen)\n .apply(input);\n }\n}\n\n// Usage\nDataPipeline textPipeline = new DataPipeline()\n .addStep(String::trim)\n .addStep(String::toLowerCase)\n .addStep(s -> s.replaceAll(\"\\\\s+\", \" \"))\n .addStep(s -> s.replaceAll(\"[^a-z0-9 ]\", \"\"));\n\nString cleaned = textPipeline.process(\" Hello, WORLD! \");\n// Result: \"hello world\"\n\n// ✅ Type-changing pipeline\npublic class TransformPipeline {\n\n public OrderSummary process(RawOrder raw) {\n return Optional.of(raw)\n .map(this::validate)\n .map(this::enrichWithCustomerData)\n .map(this::calculatePricing)\n .map(this::applyDiscounts)\n .map(this::generateSummary)\n .orElseThrow(() -> new ProcessingException(\"Pipeline failed\"));\n }\n\n private ValidatedOrder validate(RawOrder raw) { ... }\n private EnrichedOrder enrichWithCustomerData(ValidatedOrder order) { ... }\n private PricedOrder calculatePricing(EnrichedOrder order) { ... }\n private DiscountedOrder applyDiscounts(PricedOrder order) { ... }\n private OrderSummary generateSummary(DiscountedOrder order) { ... }\n}\n```\n\n---\n\n### Pattern 7: Collectors for Complex Aggregations\n\n```java\n// ✅ Custom collectors\n\npublic class OrderCollectors {\n\n // Summarize order statistics\n public static Collector summarizing() {\n return Collector.of(\n OrderStatistics::new,\n OrderStatistics::accept,\n OrderStatistics::combine,\n Collector.Characteristics.UNORDERED);\n }\n\n public static class OrderStatistics {\n private int count;\n private BigDecimal total = BigDecimal.ZERO;\n private BigDecimal min = null;\n private BigDecimal max = null;\n\n void accept(Order order) {\n count++;\n BigDecimal amount = order.getTotal();\n total = total.add(amount);\n min = min == null ? amount : min.min(amount);\n max = max == null ? amount : max.max(amount);\n }\n\n OrderStatistics combine(OrderStatistics other) {\n count += other.count;\n total = total.add(other.total);\n min = min == null ? other.min :\n (other.min == null ? min : min.min(other.min));\n max = max == null ? other.max :\n (other.max == null ? max : max.max(other.max));\n return this;\n }\n\n public int getCount() { return count; }\n public BigDecimal getTotal() { return total; }\n public BigDecimal getAverage() {\n return count == 0 ? BigDecimal.ZERO :\n total.divide(BigDecimal.valueOf(count), RoundingMode.HALF_UP);\n }\n }\n}\n\n// Usage\nOrderStatistics stats = orders.stream()\n .filter(Order::isCompleted)\n .collect(OrderCollectors.summarizing());\n\nSystem.out.printf(\"Orders: %d, Total: $%.2f, Average: $%.2f%n\",\n stats.getCount(), stats.getTotal(), stats.getAverage());\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Mixing Side Effects in Streams\n\n```java\n// ❌ Side effects in stream\nList results = new ArrayList<>();\norders.stream()\n .filter(Order::isActive)\n .forEach(order -> {\n results.add(order.getId()); // Side effect!\n sendNotification(order); // Another side effect!\n });\n\n// ✅ Separate concerns\nList activeOrderIds = orders.stream()\n .filter(Order::isActive)\n .map(Order::getId)\n .toList();\n\norders.stream()\n .filter(Order::isActive)\n .forEach(this::sendNotification); // Side effects explicit and separate\n```\n\n### Mistake 2: Overusing Streams\n\n```java\n// ❌ Stream for simple null check\nOptional.ofNullable(user)\n .map(User::getName)\n .ifPresent(System.out::println);\n\n// ✅ Simple conditional is clearer\nif (user != null) {\n System.out.println(user.getName());\n}\n\n// ❌ Stream with index manipulation\nIntStream.range(0, list.size())\n .filter(i -> list.get(i).isActive())\n .forEach(i -> process(list.get(i), i));\n\n// ✅ Loop is clearer for index operations\nfor (int i = 0; i < list.size(); i++) {\n if (list.get(i).isActive()) {\n process(list.get(i), i);\n }\n}\n```\n\n---\n\n## 🐛 Debug This: The Stream Side Effect\n\nA developer reports: \"My parallel stream works fine in tests but produces inconsistent results in production!\"\n\n```java\npublic class OrderProcessor {\n private final List processedIds = new ArrayList<>();\n private BigDecimal totalRevenue = BigDecimal.ZERO;\n\n public ProcessingResult processOrders(List orders) {\n orders.parallelStream()\n .filter(Order::isValid)\n .forEach(order -> {\n // Process the order\n processOrder(order);\n\n // Track processed IDs\n processedIds.add(order.getId());\n\n // Accumulate revenue\n totalRevenue = totalRevenue.add(order.getTotal());\n });\n\n return new ProcessingResult(\n processedIds.size(),\n totalRevenue,\n List.copyOf(processedIds)\n );\n }\n\n private void processOrder(Order order) {\n // Business logic...\n }\n}\n\n// Test (sequential, works fine):\n// processOrders(List.of(order1, order2, order3)) → count: 3, consistent\n\n// Production (parallel, 1000 orders):\n// Run 1: count: 987, total: $45,234.00\n// Run 2: count: 992, total: $45,891.00 // Different!\n// Run 3: count: 989, total: $45,567.00 // Different again!\n```\n\n**Why are the results inconsistent, and how would you fix it?**\n\n---\n\n**✅ Solution:**\n\nThree major problems with parallel streams and shared mutable state:\n\n1. **`ArrayList` is not thread-safe** - concurrent `add()` calls can corrupt the list or lose elements\n2. **`BigDecimal` accumulation is not atomic** - `totalRevenue = totalRevenue.add(...)` is a read-modify-write operation that suffers from race conditions\n3. **Side effects in `forEach`** - parallel streams and side effects don't mix\n\n**Correct functional approach:**\n\n```java\npublic class OrderProcessor {\n\n public ProcessingResult processOrders(List orders) {\n // Use stream operations that are inherently thread-safe\n\n List validOrders = orders.parallelStream()\n .filter(Order::isValid)\n .peek(this::processOrder) // Side effect isolated\n .toList();\n\n List processedIds = validOrders.stream()\n .map(Order::getId)\n .toList();\n\n BigDecimal totalRevenue = validOrders.stream()\n .map(Order::getTotal)\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n\n return new ProcessingResult(\n processedIds.size(),\n totalRevenue,\n processedIds\n );\n }\n}\n\n// Alternative: Single pass with custom collector\npublic ProcessingResult processOrdersCollector(List orders) {\n return orders.parallelStream()\n .filter(Order::isValid)\n .peek(this::processOrder)\n .collect(Collector.of(\n () -> new Object[] { new ArrayList(), BigDecimal.ZERO },\n (acc, order) -> {\n synchronized (acc) {\n ((List) acc[0]).add(order.getId());\n acc[1] = ((BigDecimal) acc[1]).add(order.getTotal());\n }\n },\n (acc1, acc2) -> {\n synchronized (acc1) {\n ((List) acc1[0]).addAll((List) acc2[0]);\n acc1[1] = ((BigDecimal) acc1[1]).add((BigDecimal) acc2[1]);\n }\n return acc1;\n },\n acc -> new ProcessingResult(\n ((List) acc[0]).size(),\n (BigDecimal) acc[1],\n List.copyOf((List) acc[0])\n )\n ));\n}\n```\n\n**The lesson:** Never use shared mutable state with parallel streams. Use immutable collectors and functional operations that return new values.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Convert to Pure Function\n⭐ Difficulty: Easy | ⏱️ Time: 10 minutes\n\n**Task:** Refactor this impure function to be pure.\n\n```java\npublic class DiscountCalculator {\n private double discountRate = 0.1;\n private List appliedCodes = new ArrayList<>();\n\n public double calculateDiscount(double price, String code) {\n if (code != null && !appliedCodes.contains(code)) {\n appliedCodes.add(code); // Side effect!\n discountRate += 0.05; // Modifies state!\n }\n return price * discountRate;\n }\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class DiscountCalculator {\n\n public DiscountResult calculateDiscount(\n double price,\n double baseRate,\n String code,\n Set appliedCodes) {\n\n boolean isNewCode = code != null && !appliedCodes.contains(code);\n double effectiveRate = isNewCode ? baseRate + 0.05 : baseRate;\n double discount = price * effectiveRate;\n\n Set newAppliedCodes = isNewCode\n ? Stream.concat(appliedCodes.stream(), Stream.of(code))\n .collect(Collectors.toSet())\n : appliedCodes;\n\n return new DiscountResult(discount, effectiveRate, newAppliedCodes);\n }\n\n public record DiscountResult(\n double discount,\n double newRate,\n Set appliedCodes) {}\n}\n```\n\n---\n\n### Exercise 2: Stream Refactoring\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Refactor these imperative loops to functional streams.\n\n```java\npublic class ReportGenerator {\n\n public Map generateSalesReport(List sales) {\n Map result = new HashMap<>();\n for (Sale sale : sales) {\n if (sale.getAmount() > 100) {\n String category = sale.getCategory();\n double current = result.getOrDefault(category, 0.0);\n result.put(category, current + sale.getAmount());\n }\n }\n return result;\n }\n\n public List getTopCustomers(List orders, int limit) {\n Map customerTotals = new HashMap<>();\n for (Order order : orders) {\n String customerId = order.getCustomerId();\n double current = customerTotals.getOrDefault(customerId, 0.0);\n customerTotals.put(customerId, current + order.getTotal());\n }\n\n List> sorted = new ArrayList<>(customerTotals.entrySet());\n sorted.sort((a, b) -> Double.compare(b.getValue(), a.getValue()));\n\n List topCustomers = new ArrayList<>();\n for (int i = 0; i < Math.min(limit, sorted.size()); i++) {\n topCustomers.add(sorted.get(i).getKey());\n }\n return topCustomers;\n }\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class ReportGenerator {\n\n public Map generateSalesReport(List sales) {\n return sales.stream()\n .filter(sale -> sale.getAmount() > 100)\n .collect(Collectors.groupingBy(\n Sale::getCategory,\n Collectors.summingDouble(Sale::getAmount)));\n }\n\n public List getTopCustomers(List orders, int limit) {\n return orders.stream()\n .collect(Collectors.groupingBy(\n Order::getCustomerId,\n Collectors.summingDouble(Order::getTotal)))\n .entrySet().stream()\n .sorted(Map.Entry.comparingByValue().reversed())\n .limit(limit)\n .map(Map.Entry::getKey)\n .toList();\n }\n}\n```\n\n---\n\n### Exercise 3: Higher-Order Function\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Create a higher-order function for retry logic with exponential backoff.\n\n```java\n// Create withRetry that:\n// 1. Takes a Supplier and max attempts\n// 2. Retries with exponential backoff (100ms, 200ms, 400ms...)\n// 3. Returns the result or throws after all retries fail\n\nString result = withRetry(3, () -> unreliableService.fetchData());\n```\n\n**✅ Solution:**\n\n```java\npublic class RetryUtils {\n\n public static T withRetry(int maxAttempts, Supplier operation) {\n return withRetry(maxAttempts, 100, operation);\n }\n\n public static T withRetry(\n int maxAttempts,\n long initialDelayMs,\n Supplier operation) {\n\n Exception lastException = null;\n long delay = initialDelayMs;\n\n for (int attempt = 1; attempt <= maxAttempts; attempt++) {\n try {\n return operation.get();\n } catch (Exception e) {\n lastException = e;\n if (attempt < maxAttempts) {\n try {\n Thread.sleep(delay);\n delay *= 2; // Exponential backoff\n } catch (InterruptedException ie) {\n Thread.currentThread().interrupt();\n throw new RuntimeException(\"Retry interrupted\", ie);\n }\n }\n }\n }\n\n throw new RuntimeException(\n \"Operation failed after \" + maxAttempts + \" attempts\",\n lastException);\n }\n\n // Functional variant with custom exception handling\n public static T withRetry(\n int maxAttempts,\n Supplier operation,\n Predicate retryCondition) {\n\n Exception lastException = null;\n\n for (int attempt = 1; attempt <= maxAttempts; attempt++) {\n try {\n return operation.get();\n } catch (Exception e) {\n lastException = e;\n if (!retryCondition.test(e) || attempt >= maxAttempts) {\n throw new RuntimeException(\"Retry failed\", e);\n }\n }\n }\n\n throw new RuntimeException(\"Unexpected state\", lastException);\n }\n}\n\n// Usage\nString data = RetryUtils.withRetry(3, () -> api.fetchData());\n\n// With custom condition\nString data = RetryUtils.withRetry(\n 5,\n () -> api.fetchData(),\n e -> e instanceof TimeoutException);\n```\n\n---\n\n### Exercise 4: Immutable Builder\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Create an immutable query builder using functional patterns.\n\n```java\n// Each method should return a new instance, not modify state\nQuery query = Query.select(\"name\", \"email\")\n .from(\"users\")\n .where(\"active\", true)\n .where(\"age\", \">\", 18)\n .orderBy(\"name\")\n .limit(10);\n\nString sql = query.toSql();\n// SELECT name, email FROM users WHERE active = true AND age > 18 ORDER BY name LIMIT 10\n```\n\n**✅ Solution:**\n\n```java\npublic record Query(\n List columns,\n String table,\n List conditions,\n List orderColumns,\n Integer limit) {\n\n public Query {\n columns = List.copyOf(columns);\n conditions = List.copyOf(conditions);\n orderColumns = List.copyOf(orderColumns);\n }\n\n public static Query select(String... columns) {\n return new Query(\n List.of(columns),\n null,\n List.of(),\n List.of(),\n null);\n }\n\n public Query from(String table) {\n return new Query(columns, table, conditions, orderColumns, limit);\n }\n\n public Query where(String column, Object value) {\n return where(column, \"=\", value);\n }\n\n public Query where(String column, String operator, Object value) {\n List newConditions = new ArrayList<>(conditions);\n newConditions.add(new Condition(column, operator, value));\n return new Query(columns, table, newConditions, orderColumns, limit);\n }\n\n public Query orderBy(String... columns) {\n return new Query(this.columns, table, conditions, List.of(columns), limit);\n }\n\n public Query limit(int limit) {\n return new Query(columns, table, conditions, orderColumns, limit);\n }\n\n public String toSql() {\n StringBuilder sql = new StringBuilder();\n sql.append(\"SELECT \").append(String.join(\", \", columns));\n sql.append(\" FROM \").append(table);\n\n if (!conditions.isEmpty()) {\n sql.append(\" WHERE \");\n sql.append(conditions.stream()\n .map(Condition::toSql)\n .collect(Collectors.joining(\" AND \")));\n }\n\n if (!orderColumns.isEmpty()) {\n sql.append(\" ORDER BY \").append(String.join(\", \", orderColumns));\n }\n\n if (limit != null) {\n sql.append(\" LIMIT \").append(limit);\n }\n\n return sql.toString();\n }\n\n public record Condition(String column, String operator, Object value) {\n public String toSql() {\n return column + \" \" + operator + \" \" + formatValue(value);\n }\n\n private String formatValue(Object v) {\n if (v instanceof String) return \"'\" + v + \"'\";\n return String.valueOf(v);\n }\n }\n}\n```\n\n---\n\n### Exercise 5: Custom Collector\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 25 minutes\n\n**Task:** Create a custom collector that computes running statistics.\n\n```java\n// Create a collector that tracks:\n// - count, sum, min, max, average\n// - works with BigDecimal\n// - supports parallel streams\n\nOrderStats stats = orders.stream()\n .map(Order::getTotal)\n .collect(BigDecimalStats.collector());\n\nstats.getCount(); // 100\nstats.getSum(); // 15234.50\nstats.getMin(); // 10.00\nstats.getMax(); // 500.00\nstats.getAverage(); // 152.35\n```\n\n**✅ Solution:**\n\n```java\npublic class BigDecimalStats {\n private long count = 0;\n private BigDecimal sum = BigDecimal.ZERO;\n private BigDecimal min = null;\n private BigDecimal max = null;\n\n public static Collector collector() {\n return Collector.of(\n BigDecimalStats::new,\n BigDecimalStats::accept,\n BigDecimalStats::combine,\n Collector.Characteristics.UNORDERED\n );\n }\n\n private void accept(BigDecimal value) {\n if (value == null) return;\n count++;\n sum = sum.add(value);\n min = (min == null) ? value : min.min(value);\n max = (max == null) ? value : max.max(value);\n }\n\n private BigDecimalStats combine(BigDecimalStats other) {\n count += other.count;\n sum = sum.add(other.sum);\n min = combineMin(min, other.min);\n max = combineMax(max, other.max);\n return this;\n }\n\n private static BigDecimal combineMin(BigDecimal a, BigDecimal b) {\n if (a == null) return b;\n if (b == null) return a;\n return a.min(b);\n }\n\n private static BigDecimal combineMax(BigDecimal a, BigDecimal b) {\n if (a == null) return b;\n if (b == null) return a;\n return a.max(b);\n }\n\n public long getCount() { return count; }\n public BigDecimal getSum() { return sum; }\n public BigDecimal getMin() { return min; }\n public BigDecimal getMax() { return max; }\n\n public BigDecimal getAverage() {\n if (count == 0) return BigDecimal.ZERO;\n return sum.divide(BigDecimal.valueOf(count), 2, RoundingMode.HALF_UP);\n }\n\n public Optional getAverageOptional() {\n if (count == 0) return Optional.empty();\n return Optional.of(getAverage());\n }\n\n @Override\n public String toString() {\n return String.format(\n \"BigDecimalStats{count=%d, sum=%s, min=%s, max=%s, avg=%s}\",\n count, sum, min, max, getAverage());\n }\n}\n\n// Usage\nBigDecimalStats stats = orders.parallelStream()\n .map(Order::getTotal)\n .collect(BigDecimalStats.collector());\n\nSystem.out.printf(\"Processed %d orders: $%s total, avg $%s%n\",\n stats.getCount(), stats.getSum(), stats.getAverage());\n```\n\n---\n\n## 🎤 Interview Questions\n\n### Q1: What makes a function \"pure\"?\n\n**Answer:**\n1. Same input always produces same output (deterministic)\n2. No side effects (doesn't modify external state)\n3. Doesn't depend on external mutable state\n\nBenefits: Testable, cacheable, thread-safe, composable.\n\n### Q2: When should you prefer loops over streams?\n\n**Answer:**\n- Complex control flow with early exit\n- Need to track multiple mutable variables\n- Index-based operations\n- Performance-critical code with small collections\n- Code clarity when stream chain becomes complex\n\n---\n\n## 📝 Summary\n\n| Concept | Use When |\n|---------|----------|\n| Pure Functions | Calculations, transformations |\n| Immutability | Value objects, DTOs, thread safety |\n| Streams | Collection transformations, aggregations |\n| Higher-Order Functions | Reusable cross-cutting logic |\n| Optional | Return values that might be absent |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review pure vs impure functions mental model | 5 min |\n| Day 3 | Redo Exercise 2 (Stream Refactoring) | 15 min |\n| Day 7 | Answer interview questions without looking | 10 min |\n| Day 14 | Redo Debug This (Stream Side Effect) | 15 min |\n| Day 30 | Find one impure function in your codebase to refactor | 20 min |\n\n---\n\n*Next: [Part 12: Chain of Responsibility & Pipeline]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.764416Z","createdAt","2026-06-10T07:19:24.765240Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",16,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",11,"author",{"_31":55,"_98":57,"_99":100,"_101":102,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":-5},"category",{"_31":94,"_72":59,"_35":95,"_75":96,"_97":-5},"tags",[78,79,80,81],"series",{"_31":16,"_72":73,"_35":74,"_75":76,"_77":23},"name","Advanced Clean Code Patterns: From Principles to Production Mastery","advanced-clean-code-patterns","description","A comprehensive 26-part series covering enterprise-grade clean code patterns for Java developers. From SOLID principles and code smells through refactoring patterns, error handling, validation, to legacy modernization and modern Java 21+ features. Includes real production stories, mental models, exercises, and 150+ interview questions.","isActive",{"_31":91,"_72":92,"_35":93},{"_31":88,"_72":89,"_35":90},{"_31":85,"_72":86,"_35":87},{"_31":82,"_72":83,"_35":84},58,"Streams","streams",57,"Lambda","lambda",59,"Immutability","immutability",56,"Functional Programming","functional-programming",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]