feat(functional-interfaces): demonstrate Function, Predicate, Consumer, and Supplier usage

What
- Added FunctionalInterfaceExample class showcasing four core functional interfaces from `java.util.function`:
  1. Function<T,R> → transforms input to output.
     - Example: String → Integer (length).
  2. Predicate<T> → evaluates condition, returns boolean.
     - Example: check if an integer is even.
  3. Consumer<T> → consumes input, no return.
     - Example: prints a message.
  4. Supplier<T> → supplies a value without input.
     - Example: generates random numbers.

Why
- Functional interfaces are the foundation of Java 8’s functional programming.
- Provides concrete examples for commonly used built-in interfaces.
- Clarifies how lambdas map directly to single abstract methods.

Logic
1. Function<String,Integer> stringLength = str -> str.length();
   - Calls `apply("Java8")`, prints length = 5.
2. Predicate<Integer> isEven = n -> n % 2 == 0;
   - Tests with 10 (true) and 7 (false).
3. Consumer<String> printMessage = msg -> System.out.println(msg);
   - Accepts and prints a custom string.
4. Supplier<Double> randomSupplier = () -> Math.random();
   - Generates and supplies a random double value.

Real-life applications
- Function<T,R>: data transformation (DTO mapping, stream map operations).
- Predicate<T>: filtering collections (stream filters, input validation).
- Consumer<T>: logging, notifications, UI rendering actions.
- Supplier<T>: lazy initialization, providing IDs, timestamps, or random values.

Notes
- Each of these interfaces has exactly one abstract method, making them functional interfaces.
- Can be composed or combined with methods like `andThen`, `or`, `negate` for more complex logic.
- Central to Java Streams API and event-driven programming.

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

Author: Someshdiwan

Java 8 Crash Course/Functional Interface/src/FunctionalInterfaceExample.java

@@ -0,0 +1,47 @@
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+public class FunctionalInterfaceExample {
+    public static void main(String[] args) {
+        // 1. Function<T, R>
+        // Takes an input of type T, returns an output of type R
+        // Example: Convert String -> Integer (length of string)
+
+        Function<String, Integer> stringLength = str -> str.length();
+        System.out.println("Function Example: Length of 'Java8' = " + stringLength.apply("Java8"));
+
+        // 2. Predicate<T>
+        // Takes an input of type T, returns boolean
+        // Example: Check if a number is even
+        Predicate<Integer> isEven = n -> n % 2 == 0;
+        System.out.println("Predicate Example: Is 10 even? " + isEven.test(10));
+        System.out.println("Predicate Example: Is 7 even? " + isEven.test(7));
+
+        // 3. Consumer<T>
+        // Takes an input of type T, returns nothing (just consumes it)
+        // Example: Print a message to console
+        Consumer<String> printMessage = msg -> System.out.println("Consumer Example: " + msg);
+        printMessage.accept("Hello from Consumer!");
+
+        // 4. Supplier<T>
+        // Takes no input, only supplies a value of type T
+        // Example: Supply a random number
+        Supplier<Double> randomSupplier = () -> Math.random();
+        System.out.println("Supplier Example: Random number = " + randomSupplier.get());
+
+        /*
+        Quick Recap (Why Functional Interfaces are powerful)
+         - Function   → Transform data
+         - Predicate  → Filter data (boolean logic)
+         - Consumer   → Perform action (like printing, logging)
+         - Supplier   → Provide data (like random numbers, IDs, timestamps)
+
+         •	Function = input → output
+	     •	Predicate = test condition → boolean
+	     •	Consumer = just use input, no return
+	     •	Supplier = only return, no input
+        */
+    }
+}