feat(streams): demonstrate parallelStream transformations with map, filter, distinct, and sorted

What
- Added `Test.java` showcasing multiple parallel stream operations:
  - Squaring numbers (`map(x -> x*x)`).
  - Filtering even numbers (`filter(x -> x % 2 == 0)`).
  - Dividing even numbers by 2 (`map(x -> x/2)`).
  - Combining `map`, `distinct`, and `sorted` for ordered unique results.
- Collected results using `Collectors.toList()` for easy inspection.

Why
- Parallel streams in Java 8+ allow data processing across multiple CPU cores with minimal code changes.
- Demonstrates common transformations (`map`, `filter`, `distinct`, `sorted`) under parallel execution.
- Reinforces difference between declarative, functional pipeline vs imperative loops.

Logic
1. **Squaring numbers**
   - Input: `[1..10]`
   - Pipeline: `parallelStream().map(x -> x*x)`
   - Output: `[1,4,9,16,25,36,49,64,81,100]`

2. **Filtering even numbers**
   - Predicate: `x % 2 == 0`
   - Output: `[2,4,6,8,10]`

3. **Custom transformation (divide evens by 2)**
   - Filter evens, then `map(x -> x/2)`
   - Output: `[1,2,3,4,5]`

4. **Distinct + sorted after doubling**
   - Multiply each element by 2
   - Ensure uniqueness with `distinct()`
   - Order results with `sorted()`
   - Output: `[2,4,6,8,10,12,14,16,18,20]`

Key points
- `parallelStream()` automatically partitions work across CPU cores.
- Order of elements in intermediate pipelines may vary, but `sorted()` restores deterministic ordering.
- `distinct()` ensures uniqueness (useful for deduplication in parallel pipelines).
- Collectors unify results into a single collection after parallel execution.

Real-world applications
- Squaring/transformation → numerical simulations, matrix computations.
- Filtering → selecting relevant DB/API results in multi-core processing.
- Distinct + sorted → deduplication and ordering of large log or transaction datasets.
- Parallel pipelines → speed up analytics in back-end systems with large data sets.

Notes
- Parallel streams use the common ForkJoinPool with `Runtime.getRuntime().availableProcessors()` threads.
- Avoid side effects or shared mutable state in lambdas; correctness may break under parallel execution.
- Best for CPU-intensive, independent tasks on medium-to-large datasets.

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

Author: Someshdiwan

Java 8 Crash Course/Java 8 Streams/Parallel Streams/src/Test.java

@@ -0,0 +1,46 @@
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Test {
+    public static void main(String[] args) {
+        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
+
+        // sing parallelStream() → parallel processing with multiple threads.
+        // By default, the number of threads = no. of available CPU cores.
+        List<Integer> squaredParallel =
+                list.parallelStream()
+                        .map(x -> x * x) // Each element → squared
+                        .collect(Collectors.toList());
+
+        System.out.println("Squares (Parallel): " + squaredParallel);
+
+        // Filtering even numbers in parallel
+        List<Integer> evenParallel =
+                list.parallelStream()
+                        .filter(x -> x % 2 == 0)
+                        .collect(Collectors.toList());
+
+        System.out.println("Even Numbers (Parallel): " + evenParallel);
+
+        // Custom transformation → Divide even numbers by 2
+        List<Integer> dividedParallel =
+                list.parallelStream()
+                        .filter(x -> x % 2 == 0)
+                        .map(x -> x / 2)
+                        .collect(Collectors.toList());
+
+        System.out.println("Even Numbers ÷ 2 (Parallel): " + dividedParallel);
+
+        // Distinct + Sorted (Parallel)
+        List<Integer> distinctSortedParallel =
+                list.parallelStream()
+                        .map(x -> x * 2) // Multiply by 2
+                        .distinct()
+                        .sorted()
+                        .collect(Collectors.toList());
+
+        System.out.println("Distinct + Sorted (Parallel): " + distinctSortedParallel);
+    }
+}
+