Added Map Reduce Design Pattern

map-reduce/README.md

@@ -0,0 +1,231 @@
+---
+title: "MapReduce Pattern in Java"
+shortTitle: MapReduce
+description: "Learn the MapReduce pattern in Java with real-world examples, class diagrams, and tutorials. Understand its intent, applicability, benefits, and known uses to enhance your design pattern knowledge."
+category: Performance optimization
+language: en
+tag:
+    - Data processing
+    - Code simplification
+    - Delegation
+    - Performance
+---
+
+## Also known as
+
+* Split-Apply-Combine Strategy
+* Scatter-Gather Pattern
+
+## Intent of Map Reduce Design Pattern
+
+MapReduce aims to process and generate large datasets with a parallel, distributed algorithm on a cluster. It divides the workload into two main phases: Map and Reduce, allowing for efficient parallel processing of data.
+
+## Detailed Explanation of Map Reduce Pattern with Real-World Examples
+
+Real-world example
+
+> Imagine a large e-commerce company that wants to analyze its sales data across multiple regions. They have terabytes of transaction data stored across hundreds of servers. Using MapReduce, they can efficiently process this data to calculate total sales by product category. The Map function would process individual sales records, emitting key-value pairs of (category, sale amount). The Reduce function would then sum up all sale amounts for each category, producing the final result.
+
+In plain words
+
+> MapReduce splits a large problem into smaller parts, processes them in parallel, and then combines the results.
+
+Wikipedia says
+
+> "MapReduce is a programming model and associated implementation for processing and generating big data sets with a parallel, distributed algorithm on a cluster".
+MapReduce consists of two main steps:
+The "Map" step: The master node takes the input, divides it into smaller sub-problems, and distributes them to worker nodes. A worker node may do this again in turn, leading to a multi-level tree structure. The worker node processes the smaller problem, and passes the answer back to its master node.
+The "Reduce" step: The master node then collects the answers to all the sub-problems and combines them in some way to form the output – the answer to the problem it was originally trying to solve.
+This approach allows for efficient processing of vast amounts of data across multiple machines, making it a fundamental technique in big data analytics and distributed computing.
+
+## Programmatic Example of Map Reduce in Java
+
+### 1. Map Phase (Splitting & Processing Data)
+
+* The Mapper takes an input string, splits it into words, and counts occurrences.
+* Output: A map {word → count} for each input line.
+#### `Mapper.java`
+```java
+public class Mapper {
+    public static Map<String, Integer> map(String input) {
+        Map<String, Integer> wordCount = new HashMap<>();
+        String[] words = input.split("\\s+");
+        for (String word : words) {
+            word = word.toLowerCase().replaceAll("[^a-z]", "");
+            if (!word.isEmpty()) {
+                wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
+            }
+        }
+        return wordCount;
+    }
+}
+```
+Example Input: ```"Hello world hello"```
+Output: ```{hello=2, world=1}```
+
+### 2. Shuffle Phase (Grouping Data by Key)
+
+* The Shuffler collects key-value pairs from multiple mappers and groups values by key.
+#### `Shuffler.java`
+```java
+public class Shuffler {
+    public static Map<String, List<Integer>> shuffleAndSort(List<Map<String, Integer>> mapped) {
+        Map<String, List<Integer>> grouped = new HashMap<>();
+        for (Map<String, Integer> map : mapped) {
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                grouped.putIfAbsent(entry.getKey(), new ArrayList<>());
+                grouped.get(entry.getKey()).add(entry.getValue());
+            }
+        }
+        return grouped;
+    }
+}
+```
+Example Input: 
+```
+[
+    {"hello": 2, "world": 1},
+    {"hello": 1, "java": 1}
+]
+```
+Output: 
+```
+{
+    "hello": [2, 1],
+    "world": [1],
+    "java": [1]
+}
+```
+
+### 3. Reduce Phase (Aggregating Results)
+
+* The Reducer sums up occurrences of each word.
+#### `Reducer.java`
+```java
+public class Reducer {
+    public static List<Map.Entry<String, Integer>> reduce(Map<String, List<Integer>> grouped) {
+        Map<String, Integer> reduced = new HashMap<>();
+        for (Map.Entry<String, List<Integer>> entry : grouped.entrySet()) {
+            reduced.put(entry.getKey(), entry.getValue().stream().mapToInt(Integer::intValue).sum());
+        }
+
+        List<Map.Entry<String, Integer>> result = new ArrayList<>(reduced.entrySet());
+        result.sort(Map.Entry.comparingByValue(Comparator.reverseOrder()));
+        return result;
+    }
+}
+```
+Example Input:
+```
+{
+    "hello": [2, 1],
+    "world": [1],
+    "java": [1]
+}
+```
+Output:
+```
+[
+    {"hello": 3},
+    {"world": 1},
+    {"java": 1}
+]
+```
+
+### 4. Running the Full MapReduce Process
+
+* The MapReduce class coordinates the three steps.
+#### `MapReduce.java`
+```java
+public class MapReduce {
+    public static List<Map.Entry<String, Integer>> mapReduce(List<String> inputs) {
+        List<Map<String, Integer>> mapped = new ArrayList<>();
+        for (String input : inputs) {
+            mapped.add(Mapper.map(input));
+        }
+
+        Map<String, List<Integer>> grouped = Shuffler.shuffleAndSort(mapped);
+
+        return Reducer.reduce(grouped);
+    }
+}
+```
+
+### 4. Main Execution (Calling MapReduce)
+
+* The Main class executes the MapReduce pipeline and prints the final word count.
+#### `Main.java`
+```java
+  public static void main(String[] args) {
+    List<String> inputs = Arrays.asList(
+            "Hello world hello",
+            "MapReduce is fun",
+            "Hello from the other side",
+            "Hello world"
+    );
+    List<Map.Entry<String, Integer>> result = MapReduce.mapReduce(inputs);
+    for (Map.Entry<String, Integer> entry : result) {
+        System.out.println(entry.getKey() + ": " + entry.getValue());
+    }
+}
+```
+
+Output:
+```
+hello: 4
+world: 2
+the: 1
+other: 1
+side: 1
+mapreduce: 1
+is: 1
+from: 1
+fun: 1
+```
+
+## When to Use the Map Reduce Pattern in Java
+
+Use MapReduce when:
+* Processing large datasets that don't fit into a single machine's memory
+* Performing computations that can be parallelized
+* Dealing with fault-tolerant and distributed computing scenarios
+* Analyzing log files, web crawl data, or scientific data
+
+## Map Reduce Pattern Java Tutorials
+
+* [MapReduce Tutorial(Apache Hadoop)](https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html)
+* [MapReduce Example(Simplilearn)](https://www.youtube.com/watch?v=l2clwKnrtO8)
+
+## Benefits and Trade-offs of Map Reduce Pattern
+
+Benefits:
+
+* Scalability: Can process vast amounts of data across multiple machines
+* Fault-tolerance: Handles machine failures gracefully
+* Simplicity: Abstracts complex distributed computing details
+
+Trade-offs:
+
+* Overhead: Not efficient for small datasets due to setup and coordination costs
+* Limited flexibility: Not suitable for all types of computations or algorithms
+* Latency: Batch-oriented nature may not be suitable for real-time processing needs
+
+## Real-World Applications of Map Reduce Pattern in Java
+
+* Google's original implementation for indexing web pages
+* Hadoop MapReduce for big data processing
+* Log analysis in large-scale systems
+* Genomic sequence analysis in bioinformatics
+
+## Related Java Design Patterns
+
+* Chaining Pattern
+* Master-Worker Pattern
+* Pipeline Pattern
+
+## References and Credits
+
+* [What is MapReduce](https://www.ibm.com/think/topics/mapreduce)
+* [Wy MapReduce is not dead](https://www.codemotion.com/magazine/ai-ml/big-data/mapreduce-not-dead-heres-why-its-still-ruling-in-the-cloud/)
+* [Scalabe Distributed Data Processing Solutions](https://tcpp.cs.gsu.edu/curriculum/?q=system%2Ffiles%2Fch07.pdf)
+* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3HWNf4U)

map-reduce/etc/map-reduce.urm.puml

@@ -0,0 +1,24 @@
+@startuml
+package com.iluwatar {
+  class Main {
+    + Main()
+    + main(args : String[]) {static}
+  }
+  class MapReduce {
+    + MapReduce()
+    + mapReduce(inputs : List<String>) : List<Map.Entry<String, Integer>> {static}
+  }
+  class Mapper {
+    + Mapper()
+    + map(input : String) : Map<String, Integer> {static}
+  }
+  class Reducer {
+    + Reducer()
+    + reduce(grouped : Map<String, List<Integer>>) : List<Map.Entry<String, Integer>> {static}
+  }
+  class Shuffler {
+    + Shuffler()
+    + shuffleAndSort(mapped : List<Map<String, Integer>>) : Map<String, List<Integer>> {static}
+  }
+}
+@enduml

map-reduce/pom.xml

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+
+    The MIT License
+    Copyright © 2014-2022 Ilkka Seppälä
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.iluwatar</groupId>
+        <artifactId>java-design-patterns</artifactId>
+        <version>1.26.0-SNAPSHOT</version>
+    </parent>
+    <artifactId>map-reduce</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <configuration>
+                            <archive>
+                                <manifest>
+                                    <mainClass>com.iluwatar.mapreduce.Main</mainClass>
+                                </manifest>
+                            </archive>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

map-reduce/src/main/java/com/iluwatar/Main.java

@@ -0,0 +1,55 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+/**
+ * The Main class serves as the entry point for executing the MapReduce program.
+ * It processes a list of text inputs, applies the MapReduce pattern, and prints the results.
+ */
+public class Main {
+  private static final Logger logger = Logger.getLogger(Main.class.getName());
+  /**
+   * The main method initiates the MapReduce process and displays the word count results.
+   *
+   * @param args Command-line arguments (not used).
+   */
+  public static void main(String[] args) {
+    List<String> inputs = Arrays.asList(
+        "Hello world hello",
+        "MapReduce is fun",
+        "Hello from the other side",
+        "Hello world"
+    );
+    List<Map.Entry<String, Integer>> result = MapReduce.mapReduce(inputs);
+    for (Map.Entry<String, Integer> entry : result) {
+      logger.info(entry.getKey() + ": " + entry.getValue());
+    }
+  }
+}