feat(streams): add comprehensive demo of intermediate operations in Java Streams

What
- Introduced `IntermediateOps.java` to demonstrate all key intermediate operations in Java Streams.
- Covered the following with runnable examples:
  1. **filter** → select elements matching a predicate.
  2. **map** → transform elements (e.g., to uppercase).
  3. **sorted** → sort streams (natural & custom comparator).
  4. **distinct** → remove duplicates.
  5. **limit** → truncate stream size.
  6. **skip** → ignore first N elements.
  7. **peek** → side-effect actions for debugging/inspection.
  8. **flatMap** → flatten nested collections/arrays into a single stream.
- Included use cases with lists, infinite streams (`Stream.iterate`), nested lists, and sentence splitting.

Why
- Intermediate operations are *lazy* by design: they define transformations but do not execute until a terminal op is called.
- Many developers confuse "pipeline setup" with execution → this example clarifies the difference.
- Demonstrates both stateless (filter, map) and stateful (sorted, distinct) intermediate ops.

Logic
1. **filter**:
   - `list.stream().filter(x -> x.startsWith("A"))`
   - Builds a pipeline to select elements beginning with "A".
   - Returns another stream; execution happens only when a terminal op (like `count`) is called.

2. **map**:
   - Transforms elements without changing stream size.
   - Example: convert each name to uppercase with `map(String::toUpperCase)`.

3. **sorted**:
   - Stateful op → must process all elements before emitting.
   - Demonstrated with both natural order and custom comparator (by length).

4. **distinct**:
   - Removes duplicate elements based on `equals()`.
   - Example: distinct names starting with "A".

5. **limit & skip**:
   - Useful with infinite streams (e.g., `Stream.iterate`).
   - `limit(100)` produces 100 items.
   - `skip(10).limit(100)` starts after skipping first 10.

6. **peek**:
   - Provides visibility into stream pipeline for debugging.
   - Example: printing elements as they flow through `skip` and `limit`.

7. **flatMap**:
   - Flattens nested collections (`List<List<String>>`) into a single stream.
   - Used to:
     - Convert list-of-lists of fruits into a flat uppercase list.
     - Split sentences into words and process all words in a single stream.

Real-world applications
- **Data cleaning pipelines**: filter + map + distinct for deduplication and transformations.
- **Pagination logic**: skip + limit for chunked processing.
- **Debugging ETL pipelines**: peek to log intermediate results.
- **Natural language processing**: flatMap sentences → words for indexing or analytics.
- **Sorting/grouping**: sorted as preparation step for reporting dashboards.

Notes
- Demonstrates how intermediate ops *compose* to build pipelines.
- Reinforces that *no actual computation happens until a terminal operation is invoked*.
- Aimed as both a runnable tutorial and reference example for declarative stream processing.

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

Author: Someshdiwan

JAVA8/StreamsInJAVA/src/IntermediateOps.java

@@ -0,0 +1,67 @@
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class IntermediateOps {
+    public static void main(String[] args) {
+        // Intermediate operations transform a Stream into another Stream.
+        // They are "lazy", meaning they don't execute until a terminal operation is invoked.
+
+        // 1. filter → filters elements based on a predicate
+        List<String> list = Arrays.asList("Akshit", "Ram", "Shyam", "Ghanshyam", "Akshit");
+        Stream<String> filteredStream = list.stream().filter(x -> x.startsWith("A"));
+        System.out.println(filteredStream); // Just prints stream object, not data (lazy!)
+
+        // Applying a terminal operation (count) → actually triggers filter
+        long res = list.stream().filter(x -> x.startsWith("A")).count();
+        System.out.println(res); // Number of elements starting with "A"
+
+        // 2. map → transforms each element using a function
+        Stream<String> stringStream = list.stream().map(String::toUpperCase);
+
+        // 3. sorted → sorts elements (stateful operation)
+        Stream<String> sortedStream = list.stream().sorted(); // natural order
+        Stream<String> sortedStreamUsingComparator = list.stream()
+                .sorted((a, b) -> a.length() - b.length()); // custom comparator by length
+
+        // 4. distinct → removes duplicates
+        System.out.println(list.stream().filter(x -> x.startsWith("A")).distinct().count());
+
+        // 5. limit → truncates the stream to given size
+        System.out.println(Stream.iterate(1, x -> x + 1).limit(100).count()); // 100
+
+        // 6. skip → skips first 'n' elements
+        System.out.println(Stream.iterate(1, x -> x + 1).skip(10).limit(100).count()); // 100 (but starts after skipping 10)
+
+        // 7. peek → performs an action on each element as it flows (useful for debugging)
+        Stream.iterate(1, x -> x + 1)
+                .skip(10)
+                .limit(100)
+                .peek(System.out::println) // prints elements as they pass through
+                .count();
+
+        // 8. flatMap → flattens nested structures into a single stream
+        // Useful when dealing with collections of collections
+        List<List<String>> listOfLists = Arrays.asList(
+                Arrays.asList("apple", "banana"),
+                Arrays.asList("orange", "kiwi"),
+                Arrays.asList("pear", "grape")
+        );
+        System.out.println(listOfLists.get(1).get(1)); // "kiwi"
+        System.out.println(listOfLists.stream()
+                .flatMap(x -> x.stream()) // flatten list of lists
+                .map(String::toUpperCase) // transform each element
+                .toList());
+
+        // Example with sentences → splitting into words
+        List<String> sentences = Arrays.asList(
+                "Hello world",
+                "Java streams are powerful",
+                "flatMap is useful"
+        );
+        System.out.println(sentences.stream()
+                .flatMap(sentence -> Arrays.stream(sentence.split(" "))) // split each sentence into words
+                .map(String::toUpperCase)
+                .toList());
+    }
+}