docs(Lambda): add Java Lambda Expression Cheat Sheet

What
- Added concise cheat sheet summarizing Java lambda expression syntax and usage.
- Covered:
  1. Basic syntax: (parameters) -> { body }.
  2. No parameters example with Runnable.
  3. Single parameter example with Consumer.
  4. Multiple parameters example with BiFunction.
  5. Multi-statement body with return.
  6. Method references as shorthand for lambdas.
  7. Common functional interfaces table (Runnable, Consumer, Supplier, Function, BiFunction, Predicate).
  8. Practical stream examples:
     - Filtering a list.
     - Mapping values to new form.
     - Sorting collections.
     - Reducing numbers to a sum.
- Added quick rules for parameter/return usage and method reference shorthand.

Why
- Serves as a quick reference for developers learning or revisiting lambda expressions.
- Reinforces patterns by combining short examples with explanations.
- Provides mapping between common functional interfaces and their lambda usage.
- Connects lambdas with Streams API for practical real-world applications.

How
- Organized content into numbered sections for clarity.
- Used code snippets with comments to illustrate each case.
- Provided explanation alongside code for direct understanding.
- Added tabular format for functional interfaces to show parameters, return type, and example lambda.

Logic
- Inputs: various code constructs (Runnable, Consumer, Function, etc.).
- Outputs: console prints or computed values demonstrating lambda usage.
- Flow:
  1. Define functional interface type.
  2. Assign lambda or method reference to it.
  3. Execute interface method to demonstrate effect.
- Edge cases:
  - Multi-statement lambdas require braces and explicit return.
  - Method references only work when lambda directly calls an existing method.
- Complexity / performance: lambdas compile to invokedynamic calls; more efficient than anonymous classes.
- Concurrency / thread-safety:
  - Stateless lambdas are inherently thread-safe.
  - Captured variables must be effectively final.
- Error handling:
  - Checked exceptions not directly supported in most functional interfaces; must wrap inside lambda.

Real-life applications
- Replacing verbose anonymous classes with compact lambdas for listeners and callbacks.
- Functional-style operations on collections with Streams (map, filter, reduce).
- Simplified comparator definitions for sorting.
- Building concise pipelines in data processing, logging, and validation.

Notes
- Prefer method references (Class::method) where possible for readability.
- Use @FunctionalInterface annotation when creating custom single-method interfaces.
- Keep lambdas short and clear; move complex logic to named methods for maintainability.
- Cheat sheet can be expanded with advanced usage (compose, andThen, parallelStream) for completeness.

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

Author: Someshdiwan

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

@@ -1,43 +1,39 @@
 Java Lambda Expression Cheat Sheet
 
-✅ Basic Syntax:
+Basic Syntax:
 
 (parameters) -> { body }
 
-✅ 1. No Parameters
+1. No Parameters
 
 Runnable r = () -> System.out.println("Hello, World!");
 
-✅ **Explanation:
-
+Explanation:
 -  ()  → No parameters.  
 -  -> → Lambda arrow.  
 -  System.out.println() → Action (body).
 
-
-✅ 2. Single Parameter
+2. Single Parameter
 
 Consumer<String> printer = name -> System.out.println(name);
 printer.accept("Alice");
 
 
-✅ Explanation:  
+Explanation:
 - One parameter doesn't need parentheses.  
 - Uses the Consumer functional interface to print.
 
-
-✅ 3. Multiple Parameters
+3. Multiple Parameters
 
 BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b;
 System.out.println(sum.apply(5, 10));
 
 
-✅ Explanation:
-
+Explanation:
 - Multiple parameters must be in parentheses.  
 - BiFunction takes two inputs and returns a result.  
 
-✅ 4. With Code Block (Multiple Statements)
+4. With Code Block (Multiple Statements)
 
 BiFunction<Integer, Integer, Integer> sum = (a, b) -> {
     int result = a + b;
@@ -46,26 +42,23 @@ BiFunction<Integer, Integer, Integer> sum = (a, b) -> {
 };
 sum.apply(5, 10);
 
-✅ Explanation:
-
+Explanation:
 - Use curly braces {} when the body has more than one statement.  
 - Must use return if the method has a return type.  
 
 
-✅ 5. Using Method Reference (Shortcut for Lambdas):
-
+5. Using Method Reference (Shortcut for Lambdas):
 List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
 names.forEach(System.out::println);
 
-
-✅ Explanation:
-
+Explanation:
 - System.out::println is a method reference —a cleaner way to call existing methods.  
 - Equivalent to:  
 
   names.forEach(name -> System.out.println(name));
 
-✅ 6. With Functional Interfaces
+
+6. With Functional Interfaces
 
 | Functional Interface       | Parameters | Return Type | Example Lambda                  |
 |----------------------------|------------|-------------|---------------------------------|
@@ -77,7 +70,7 @@ names.forEach(System.out::println);
 |  Predicate<T>              | 1          | boolean     | x -> x > 10                     |
 
 
-✅ 7. Common Examples:
+7. Common Examples:
 
 1.Filter a List (with filter())
 
@@ -96,23 +89,23 @@ List<String> upperCaseNames = names.stream()
 System.out.println(upperCaseNames);
 
 
-3. Sort a List
+3. Sort a List:
 
 List<String> names = Arrays.asList("Charlie", "Alice", "Bob");
 names.sort((a, b) -> a.compareTo(b));
 System.out.println(names);
 
-4. Sum of Numbers (with reduce())
+4. Sum of Numbers (with reduce()):
 
 List<Integer> numbers = Arrays.asList(1, 2, 3);
 int sum = numbers.stream()
                  .reduce(0, (a, b) -> a + b);
 System.out.println(sum);
 
-🎯 Quick Rules:
 
+Quick Rules:
 1. 0 Parameters: () -> System.out.println("Hello"); 
 2. 1 Parameter:  x -> x * 2;  
 3. Multiple Parameters: (a, b) -> a + b;  
 4. Return Statement: Use {} if there are **multiple statements.  
-5. Method Reference: Use ClassName::methodName for simple method calls.
+5. Method Reference: Use ClassName::methodName for simple method calls.