feat(Lambda): add Advanced Java Lambda Expressions tutorial with 10 examples

What
- Added a single-file tutorial (conceptual) covering 10 advanced lambda/functional examples:
  1. Returning complex objects from Supplier lambda (Person).
  2. Using Comparator with lambda for custom sorting of objects.
  3. Chaining Predicates with and(), or(), negate().
  4. Function chaining using andThen() and compose().
  5. Handling exceptions inside lambdas with try-catch.
  6. Parallel streams combined with lambda map/forEach.
  7. Defining and using a custom functional interface annotated with @FunctionalInterface.
  8. Grouping with Stream.collect(Collectors.groupingBy()).
  9. Using Optional with lambda-style callbacks and fallbacks.
  10. Combining stream operations (filter, map, reduce) to compute aggregated results.
- Each example includes short code, expected output, and a brief explanation.

Why
- Demonstrates practical, idiomatic uses of Java lambdas and functional APIs beyond trivial examples.
- Teaches common patterns developers need for modern Java: Suppliers, Comparators, Predicates, Functions, Optional, Streams, Collectors, and parallelism.
- Helps readers understand trade-offs (e.g., orElse vs orElseGet, cost of parallel streams, exception handling choices).
- Serves as a compact reference for interviews, onboarding, or quick refreshers.

How
- Present each example as a self-contained code snippet with explanation and sample output.
- Use standard java.util.function interfaces (Supplier, Predicate, Function, Comparator) and java.util.stream APIs.
- Show safe patterns: Optional usage, try-catch inside lambdas for parsing, and prefer method references where concise.
- Call out parallel stream caveats (non-deterministic order, suitability for large, CPU-bound tasks).
- Recommend small pragmatic tips inline (use orElseGet for lazy defaults, prefer Collectors.groupingBy for grouping, annotate custom interfaces with @FunctionalInterface).

Logic
- Inputs: representative hardcoded data per example (lists of Person, integers, strings) to keep demos deterministic.
- Outputs: printed console lines demonstrating behavior (shown with each snippet).
- Flow (typical per example):
  1. Create data source (List, Optional, Supplier, etc.).
  2. Apply functional operation(s) (map, filter, sort, group, reduce).
  3. Collect or consume results (forEach, System.out.println, orElse fallback).
- Edge cases and considerations:
  - Exception handling: lambdas cannot declare checked exceptions; use try-catch or wrap checked exceptions.
  - Optional: avoid using Optional as fields or in serialization; prefer for return types.
  - Parallel streams: beware of thread-safety in lambdas and non-associative operations.
  - orElse eagerly evaluates its argument; for expensive defaults use orElseGet.
  - Comparator lambdas should avoid subtraction for numeric compare; use Integer.compare to avoid overflow.
- Complexity / performance:
  - Most examples are O(n) or O(n log n) depending on sort/collect operations.
  - Parallel streams can improve throughput for large datasets but add coordination overhead.
- Concurrency / thread-safety:
  - Demonstrate that lambdas are typically stateless; if capturing mutable state, document synchronization needs.
  - When using parallelStream, show immutable/side-effect-free operations for correctness.
- Error handling:
  - Examples show graceful fallback (e.g., parse fallback to 0) and patterns for safe defaults.

Real-life applications
- Factory patterns and dependency injection using Suppliers.
- Sorting domain objects in UI or reporting pipelines.
- Validations and composite rules using Predicate chains.
- Building ETL or transformation pipelines with Function chaining and Streams.
- Safe parsing of untrusted input with lambda-embedded try-catch.
- Parallel data processing for large collections (analytics, batch jobs).
- Grouping and aggregation for reporting and dashboards using Collectors.
- Using Optional to reduce null-related bugs in service/repository APIs.

Notes
- Prefer method references (Class::method) for readability when possible.
- Annotate custom single-abstract-method interfaces with @FunctionalInterface to make intent explicit.
- Avoid returning Optional from collections or using Optional in fields; use it as a return type from methods.
- For deterministic ordering with parallel operations, ensure reduction is associative and combine functions are correct.
- This tutorial is intentionally example-driven; production code should include tests, benchmarking for parallelism, and careful resource handling.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

JAVA8/LambdaExpression/src/Advanced Java Lambda Expressions Cheat Sheet.txt renamed to Java 8 Crash Course/Lambda Expression/src/Advanced Java Lambda Expressions.txt

@@ -1,8 +1,6 @@
-Advanced Java Lambda Expressions Cheat Sheet
-
-
-✅ 1. Return Complex Objects
+Advanced Java Lambda Expressions:
 
+1. Return Complex Objects
 You can return objects from lambda expressions.
 
 import java.util.function.*;
@@ -24,12 +22,10 @@ public class LambdaDemo {
     }
 }
 
-✅ Output:
-
+Output:
 Alice
 
-✅ 2. Using Comparator for Custom Sorting
-
+2. Using Comparator for Custom Sorting
 Sort custom objects using lambdas with the Comparator interface.
 
 import java.util.*;
@@ -63,15 +59,12 @@ public class LambdaDemo {
     }
 }
 
-✅ Output:
-
+Output:
 [Bob (25), Alice (30), Charlie (35)]
 
-✅ 3. Chaining Predicates
-
+3. Chaining Predicates
 Use multiple conditions with and(), or(), and negate().
 
-
 import java.util.function.*;
 
 public class LambdaDemo {
@@ -86,15 +79,12 @@ public class LambdaDemo {
         System.out.println(isEvenAndPositive.test(-4)); // false
     }
 }
-```
-
-✅ Output:
 
+Output:
 true  
 false
 
-✅ 4. Function Chaining
-
+4. Function Chaining
 Chain transformations using andThen() and compose().
 
 import java.util.function.*;
@@ -111,16 +101,13 @@ public class LambdaDemo {
     }
 }
 
-
-✅ Output:
-
+Output:
 18
 
-✅ 5. Handling Exceptions in Lambda
+5. Handling Exceptions in Lambda
 
 Use try-catch inside lambdas for error handling.
 
-
 import java.util.function.*;
 
 public class LambdaDemo {
@@ -138,12 +125,11 @@ public class LambdaDemo {
     }
 }
 
-✅ Output:
-
+Output:
 42  
 0
 
-✅ 6. Parallel Streams with Lambda
+6. Parallel Streams with Lambda
 
 Use parallel streams for faster execution on large datasets.
 
@@ -160,17 +146,15 @@ public class LambdaDemo {
     }
 }
 
-✅ Output: (Order may vary)
-
+Output: (Order may vary)
 2  
 4  
 6  
 8  
 10  
 12
 
-✅ 7. Custom Functional Interface
-
+7. Custom Functional Interface
 You can define your own functional interface.
 
 @FunctionalInterface
@@ -186,12 +170,10 @@ public class LambdaDemo {
 }
 
 
-✅ Output:
-
+Output:
 Sum: 12
 
-✅ 8. Stream.collect() for Grouping Data
-
+8. Stream.collect() for Grouping Data
 Group elements using Collectors.groupingBy().
 
 import java.util.*;
@@ -223,12 +205,10 @@ public class LambdaDemo {
     }
 }
 
-✅ Output:
-
+Output:
 {NY=[Alice, Charlie], LA=[Bob]}
 
-✅ 9. Use Lambdas with Optional
-
+9. Use Lambdas with Optional
 Handle null values safely with Optional.
 
 import java.util.Optional;
@@ -245,11 +225,10 @@ public class LambdaDemo {
     }
 }
 
-✅ Output:
-
+Output:
 Name not found
 
-✅ 10. Combining Streams and Lambdas
+10. Combining Streams and Lambdas
 
 Example of map, filter, and reduce together:
 
@@ -269,15 +248,13 @@ public class LambdaDemo {
     }
 }
 
-✅ Output:
-
+Output:
 Result: 24
 
-🎯 Quick Recap:
-
+Quick Recap:
 1. Chain operations with andThen() and compose().  
 2. Handle exceptions using try-catch inside lambdas.  
 3. Parallel streams improve performance.  
 4. Create custom functional interfaces using @FunctionalInterface.  
 5. Group data** with Collectors.groupingBy().  
-6. Use Optional to avoid NullPointerException.
+6. Use Optional to avoid NullPointerException.