## **Streams and Lambdas in Java 8+** Java 8 introduced two powerful features that revolutionized how we write code: **Streams** and **Lambdas**. These additions brought functional programming concepts into Java, making code more concise, readable, and expressive. ## <br>**Lambdas: A Concise Way to Write Code** Before Java 8, anonymous inner classes were used to pass behavior (like `Runnable` or `Comparator`). With **lambdas**, we can write the same logic in a much cleaner way. A lambda is essentially a **short block of code** that takes parameters and returns a value. The syntax is simple: ```java (parameter) -> expression ``` ### **Example: Comparator with Lambda** Instead of: ```java Collections.sort(names, new Comparator<String>() { @Override public int compare(String a, String b) { return a.compareTo(b); } }); ``` We can now write: ```java Collections.sort(names, (a, b) -> a.compareTo(b)); ``` Lambdas work seamlessly with **functional interfaces** (interfaces with a single abstract method, like `Predicate`, `Function`, `Consumer`, etc.). --- ## <br>**Streams: Processing Data with Ease** A **Stream** is a sequence of elements that supports functional-style operations like `filter`, `map`, `reduce`, and `collect`. Unlike collections, streams don’t store data—they process it on demand. Key benefits: - **Declarative** (focus on *what* rather than *how*) - **Lazy evaluation** (operations execute only when needed) - **Parallelizable** (easy multi-threading with `parallelStream()`) ### <br>**Example: Filtering and Transforming Data** ```java List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Diana"); List<String> filteredNames = names.stream() .filter(name -> name.startsWith("A") || name.startsWith("B")) // Keep A & B .map(String::toUpperCase) // Convert to uppercase .collect(Collectors.toList()); // Collect results into a list System.out.println(filteredNames); // [ALICE, BOB] ``` ### <br>**Common Stream Operations** <table> <tr> <th>Method</th> <th>Description</th> </tr> <tr> <td>`filter(Predicate)`</td> <td>Keeps elements that match a condition</td> </tr> <tr> <td>`map(Function)`</td> <td>Transforms each element</td> </tr> <tr> <td>`sorted()`</td> <td>Sorts elements (optionally with a `Comparator`)</td> </tr> <tr> <td>`forEach(Consumer)`</td> <td>Performs an action on each element</td> </tr> <tr> <td>`reduce()`</td> <td>Combines elements (e.g., sum, max)</td> </tr> <tr> <td>`collect()`</td> <td>Converts stream back to a collection</td> </tr> </table> ### <br>**Parallel Streams for Performance** If you have large datasets, you can leverage multi-core processors: ```java List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); int sum = numbers.parallelStream() .filter(n -> n % 2 == 0) .mapToInt(n -> n * 2) .sum(); System.out.println(sum); // 60 (2*2 + 4*2 + 6*2 + 8*2 + 10*2) ``` --- ## <br>**Why Use Streams and Lambdas?** - **Readability**: Code becomes more expressive and easier to understand. - **Conciseness**: Fewer lines of code for the same logic. - **Performance**: Parallel streams improve processing speed for large datasets. By combining **lambdas** (for behavior) and **streams** (for data processing), Java developers can write cleaner, more efficient code with less boilerplate. Would you like a deeper dive into any specific aspect? 😊