feat(paradigms): add imperative vs declarative programming examples with Java Streams

What
- Added two demo classes (`Main` and `Test`) to illustrate the contrast between **imperative** and **declarative** styles in Java.
- Both programs solve the same problem: **sum of even numbers** from a collection.
- Demonstrations include:
  - **Imperative style**: explicit loops, conditions, and accumulation (`for` loop + if-check + manual sum).
  - **Declarative style**: Java Streams API with `filter`, `mapToInt`, and `sum` operations.
- Included explanatory comments in code highlighting:
  - Focus shift: *HOW (imperative)* vs *WHAT (declarative)*.
  - Advantages of declarative: reduced boilerplate, better readability, parallelization support.

Why
- Developers often default to imperative loops; this commit clarifies how Streams offer a **functional declarative alternative**.
- Establishes a clear, side-by-side comparison to help learners understand the shift in mindset.
- Highlights **practical benefits**: shorter code, cleaner intent, and easier maintainability.

Logic
1. Imperative Example
   - Initialize accumulator (`sum = 0`).
   - Loop through each element in list/array.
   - Manually check if even (`n % 2 == 0`).
   - Update accumulator.
   - Print final sum.
   - Explicitly controls every step → verbose but predictable.

2. Declarative Example
   - Express *what* is needed:
     - Convert collection to a stream.
     - Apply a filter predicate (`n % 2 == 0`).
     - Convert to primitive stream (`mapToInt` for Integer).
     - Call `sum()` terminal operation.
   - Lets the Streams API handle iteration internally.
   - Concise, more readable, and easily parallelizable (`.parallelStream()`).

Real-life applications
- **Data analytics**: summing/filtering business metrics (sales, transactions).
- **ETL pipelines**: transforming and aggregating raw datasets declaratively.
- **Backend APIs**: summarizing DB query results without verbose loops.
- **Parallel processing**: declarative pipelines can scale across CPU cores automatically.

Notes
- Imperative code gives fine-grained control but leads to boilerplate.
- Declarative code is expressive but delegates execution details to the runtime.
- Both paradigms coexist; choice depends on clarity, performance needs, and context.
- Declarative style in Java heavily relies on Streams, Lambdas, and Collectors introduced in Java 8.

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

Author: Someshdiwan

Java 8 Crash Course/Java 8 Streams/Declarative Programming/src/Main.java

@@ -0,0 +1,54 @@
+import java.util.Arrays;
+import java.util.List;
+
+public class Main {
+    public static void main(String[] args) {
+        List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
+
+        // Imperative Programming
+        // Focus: HOW to do it step-by-step
+        int sumImperative = 0;
+        for (int n : numbers) {
+            if (n % 2 == 0) {
+                sumImperative += n;
+            }
+        }
+        System.out.println("Imperative Sum of Even Numbers: " + sumImperative);
+
+        // Declarative Programming
+        // Focus: WHAT result we want
+        int sumDeclarative = numbers.stream()        // convert list to stream
+                .filter(n -> n % 2 == 0) // keep only even numbers
+                .mapToInt(Integer::intValue) // convert Integer → int
+                .sum();
+        System.out.println("Declarative Sum of Even Numbers: " + sumDeclarative);
+    }
+}
+
+/*
+1. Imperative Style:
+   - You tell the computer **how** to achieve the result.
+   - Example here:
+       ➝ create a variable sum = 0
+       ➝ loop through list
+       ➝ check even condition manually
+       ➝ add to sum
+   - Code is longer, more error-prone, but gives explicit control.
+
+2. Declarative Style:
+   - You tell the computer **what** you want.
+   - Example here:
+       ➝ take numbers
+       ➝ filter evens
+       ➝ sum them up
+   - No explicit loop or condition handling written by you.
+   - Java Streams API handles the details internally.
+
+3. Key Difference:
+   - Imperative = *HOW to do it (step-by-step instructions)*.
+   - Declarative = *WHAT result you want (describe the logic)*.
+
+✔ Imperative: Loop + condition + manual sum.
+✔ Declarative: Streams + filter + sum → concise, readable.
+✔ Declarative programming improves readability and reduces boilerplate.
+*/