docs(streams): add detailed guide and examples for Java 8 Streams API

What
- Added comprehensive documentation explaining **Java 8 Streams**:
  - Definition of a Stream (sequence of elements from collections/arrays/I/O).
  - Key characteristics:
    * Functional style (lambdas & method references).
    * Lazy evaluation (intermediates executed only when terminal ops run).
    * Pipeline processing (Source → Intermediate → Terminal).
    * No side effects (encourages pure, stateless functions).
    * Parallel execution (parallelStream() support).
  - Classification of operations:
    * Intermediate (filter, map, sorted, etc.) → lazy.
    * Terminal (forEach, collect, count, reduce, etc.) → eager, consume the stream.
  - Stream workflow steps: creation, transformation, terminal evaluation.

- Added **example programs**:
  1. **Basic Filtering**
     - Filters names starting with `"A"` and prints them.
     - Demonstrates `.filter(...)` + `.forEach(...)`.
     ```java
     names.stream().filter(n -> n.startsWith("A")).forEach(System.out::println);
     ```
     ✅ Output: `Alice`.

  2. **Collecting Results**
     - Filters even numbers into a new `List<Integer>`.
     - Uses `.collect(Collectors.toList())`.
     ✅ Output: `[2, 4]`.

  3. **Mapping and Reducing**
     - Sums integers using `.reduce(0, Integer::sum)`.
     ✅ Output: `Sum: 15`.

  4. **Parallel Streams**
     - Uses `.parallelStream()` to process elements in parallel.
     - Demonstrates unordered parallel execution.

Why
- Streams represent a **functional and declarative approach** to data processing in Java 8.
- They simplify common tasks like filtering, mapping, reducing, and collecting into **concise, readable pipelines**.
- Understanding Streams is essential for:
  - Backend data manipulation (Spring Boot, microservices).
  - Parallel processing of large datasets.
  - Replacing verbose imperative loops with functional style.

Logic
1. **Streams don’t store data** → they work over a data source.
2. **Intermediate ops are lazy** → nothing executes until a terminal operation is invoked.
3. **Terminal ops trigger execution** and consume the stream.
4. **Parallel streams** split workload across CPU cores for performance on large independent tasks.
5. **Pipeline processing** allows composition of multiple operations in a single fluent chain.

Key Takeaways
✔ Streams = functional, lazy, declarative.
✔ Intermediate ops = transformations (filter/map/sorted).
✔ Terminal ops = results (collect/reduce/forEach).
✔ Parallel streams = enable concurrency with minimal effort.
✔ Benefits = cleaner code, reduced boilerplate, efficient execution.

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

Author: Someshdiwan

JAVA8/JAVA8FeaturesUsedInStreams/src/In Java 8, Streams are a powerful and versatile API.txt renamed to Java 8 Crash Course/Java 8 Streams/src/Java 8, Streams.txt

@@ -1,20 +1,25 @@
-In Java 8, Streams are a powerful and versatile API that allows you to process collections of data (like List, Set, and Map) in a functional and declarative way. They enable you to perform complex data transformations with minimal code by chaining operations together.
+In Java 8, Streams are a powerful and versatile API that allows you to process collections of
+data (like List, Set, and Map) in a functional and declarative way.
 
-✅ What is a Stream?
+They enable you to perform complex data transformations with minimal code by chaining operations together.
 
-A Stream is a sequence of elements that you can process in a pipeline of operations. It does not store data; instead, it works on the data from a source (like a collection, array, or I/O channel).
+What is a Stream?
+A Stream is a sequence of elements that you can process in a pipeline of operations.
+It does not store data; instead, it works on the data from a source (like a collection, array, or I/O channel).
 
-✅ Key Characteristics of Streams:
+Key Characteristics of Streams:
 
 Functional Style – Emphasizes the use of lambda expressions and method references for concise and readable code.
 Lazy Evaluation – Operations are executed only when a terminal operation is called.
 Pipeline Processing – Streams support a pipeline of operations: Source → Intermediate Operations → Terminal Operation.
 No Side Effects – Streams encourage pure functions that do not modify the original data.
 Parallel Execution – Can process data in parallel using the parallelStream() method.
 
-✅ Stream Operations:
+Stream Operations:
 
-Intermediate Operations – Transform the stream (lazy evaluation). Examples:
+Intermediate Operations – Transform the stream (lazy evaluation).
+
+Examples:
 
 filter() – Filters elements based on a condition.
 map() – Transforms each element.
@@ -25,13 +30,13 @@ forEach() – Iterates over each element.
 collect() – Collects results into a collection.
 count() – Counts the elements.
 
-✅ Stream Workflow:
+Stream Workflow:
 
 Create a Stream – From collections, arrays, or other data sources.
 Apply Intermediate Operations – Transform or filter the stream.
 Perform Terminal Operation – Generate output or apply side effects.
 
-✅ Example 1: Basic Stream Operations
+Example 1: Basic Stream Operations
 
 import java.util.*;
 import java.util.stream.*;
@@ -48,10 +53,9 @@ public class Java8Demo {
 }
 
 Output:
-
 Alice
 
-✅ Example 2: Collecting Results
+Example 2: Collecting Results
 
 import java.util.*;
 import java.util.stream.*;
@@ -70,10 +74,9 @@ public class Java8Demo {
 }
 
 Output:
-
 [2, 4]
 
-✅ Example 3: Mapping and Reducing
+Example 3: Mapping and Reducing
 
 import java.util.*;
 
@@ -90,14 +93,11 @@ public class Java8Demo {
 }
 
 Output:
-
 Sum: 15
 
-✅ Parallel Streams
-
+Parallel Streams:
 For large datasets, you can use parallelStream() to process data in parallel:
 
-
 import java.util.*;
 
 public class Java8Demo {
@@ -110,8 +110,7 @@ public class Java8Demo {
     }
 }
 
-✅ Advantages of Streams:
-
+Advantages of Streams:
 Simplifies Code – Reduces boilerplate code using functional style.
 Efficient Processing – Supports lazy evaluation and parallel execution.
-Better Readability – Clear and expressive pipeline for data transformations.
+Better Readability – Clear and expressive pipeline for data transformations.