docs(streams): add beginner-friendly explanation of Java Streams with examples

What
- Added a concise overview of **Streams in Java**:
  - Definition: a way to process collections (List, Set, Map) in a pipeline style.
  - Workflow:
    1. Create → from a collection (`list.stream()`).
    2. Process → apply intermediate ops (`filter`, `map`, `sorted`).
    3. Output → use terminal ops (`forEach`, `collect`, `count`).
  - Classified operations into:
    * Intermediate (lazy) → filter(), map(), sorted().
    * Terminal (eager) → forEach(), collect(), count().

- Included a reference table summarizing common operations with their type and purpose.

- Added **simple code examples**:
  1. **Filter Example**
     - Filters even numbers from a list.
     ```java
     numbers.stream()
            .filter(n -> n % 2 == 0)
            .forEach(System.out::println);
     ```
     ✅ Output: `2, 4`.

  2. **Map Example**
     - Squares each number from a list.
     ```java
     numbers.stream()
            .map(n -> n * n)
            .forEach(System.out::println);
     ```
     ✅ Output: `1, 4, 9`.

  3. **Parallel Stream Example**
     - Demonstrated `.parallelStream()` for concurrent processing of elements in large datasets.

Why
- This update provides a **beginner-friendly, high-level introduction** to Streams, focusing on clarity and simplicity.
- Helps newcomers understand **what a stream is, how the workflow looks, and what common operations exist** before diving into advanced topics.
- Examples illustrate functional-style coding, replacing verbose loops with declarative pipelines.

Logic
1. **Stream = pipeline abstraction** over a collection.
2. **Intermediate ops** describe *what transformations to apply* but execute lazily.
3. **Terminal ops** trigger the pipeline and produce results.
4. **Parallel streams** leverage multi-core processors automatically for large independent workloads.
5. Provides **cleaner, faster, more maintainable code** compared to imperative loops.

Key Takeaways
✔ Stream = sequence of elements processed in a pipeline.
✔ Workflow = Create → Process → Output.
✔ Intermediate = lazy, Terminal = eager.
✔ Common ops = filter, map, sorted, forEach, collect, count.
✔ Parallel streams = automatic concurrency for big datasets.

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

Author: Someshdiwan

JAVA8/StreamsInJAVA/src/simplified overview of Java 8 Streams.txt renamed to Java 8 Crash Course/Java 8 Streams/src/Overview Of Java 8 Streams.txt

@@ -1,8 +1,4 @@
-Got it! Here's a simplified overview of Java 8 Streams:
-
-
-✅ 1. What is a Stream?
-
+1. What is a Stream?
 A Stream is a way to process collections of data (like List, Set, Map) in a clean and efficient way.
 
 Think of it as a pipeline where you:
@@ -12,15 +8,14 @@ Think of it as a pipeline where you:
 3. Get the result (in a new form).
 
 
-✅ 2. Basic Stream Workflow:
+2. Basic Stream Workflow:
 
 1. Create – From a collection (e.g., list.stream()).  
 2. Process – Use intermediate operations (like filter() and map()).  
 3. Output – Use terminal operations (like forEach() or collect()).
 
 
-✅ 3. Common Stream Operations:
-
+3. Common Stream Operations:
 
 | Operation     | Type           | Purpose                     |
 |---------------|----------------|-----------------------------|
@@ -32,7 +27,7 @@ Think of it as a pipeline where you:
 |  count()      | Terminal       | Count elements.              |
 
 
-✅ 4. Simple Examples:
+4. Simple Examples:
 
 1. Filter Example: (Get even numbers)
 
@@ -42,11 +37,9 @@ numbers.stream()
        .forEach(System.out::println);
 
 Output:
-
 2  
 4
 
-
 2. Map Example: (Square each number)
 
 List<Integer> numbers = Arrays.asList(1, 2, 3);
@@ -55,16 +48,15 @@ numbers.stream()
        .forEach(System.out::println);
 
 Output:
-
 1  
 4  
 9
 
-✅ 5. Parallel Stream (Faster Execution):
+5. Parallel Stream (Faster Execution):
 
 Use parallelStream() to process data in parallel for large datasets.
 
 numbers.parallelStream()
        .forEach(System.out::println);
 
-💡 Summary: Streams are used to process collections in a clean, fast, and functional way!
+Streams are used to process collections in a clean, fast, and functional way.