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

What
- Introduced `TerminalOps.java` to showcase all major terminal operations in Java Streams.
- Implemented examples with `List`, `Stream`, and Strings to demonstrate:
  1. **collect** → gather results into collections (`toList`, `Collectors.toList`).
  2. **forEach / forEachOrdered** → process elements sequentially or with order guarantees.
  3. **reduce** → accumulate elements into a single result (e.g., sum).
  4. **count** → count number of elements in stream.
  5. **anyMatch / allMatch / noneMatch** → short-circuiting predicate-based checks.
  6. **findFirst / findAny** → retrieve elements, important for sequential vs parallel streams.
  7. **toArray** → convert stream elements into an array.
  8. **min / max** → find smallest or largest element with comparators.
  9. **parallel stream behavior** → difference between `forEach` and `forEachOrdered`.
- Added multiple applied use cases:
  - Filtering and collecting names by length.
  - Squaring and sorting numbers.
  - Summing integers via `reduce`.
  - Counting occurrences of a character in a String (`chars()` stream).
  - Demonstrating **stream reuse limitation** (consumed stream cannot be reused).

Why
- Terminal operations are essential because they **trigger execution** of stream pipelines.
- Without a terminal operation, intermediate ops remain lazy and never execute.
- This file provides a consolidated tutorial for developers to understand:
  - Different result types: collections, primitives, optionals.
  - Short-circuiting behavior (`anyMatch`, `findFirst`).
  - Parallel stream ordering guarantees.

Logic
1. **collect**
   - `list.stream().skip(1).collect(Collectors.toList())` → gathers elements into a collection.
   - Modern shorthand: `list.stream().skip(1).toList()` (Java 16+).

2. **forEach / forEachOrdered**
   - `forEach` executes actions on each element (order not guaranteed in parallel).
   - `forEachOrdered` enforces encounter order in parallel streams.

3. **reduce**
   - Combines elements (e.g., sum, product, concatenation).
   - Returns an `Optional<T>` if identity not provided.

4. **count**
   - Efficient terminal op to count elements (long value).

5. **anyMatch / allMatch / noneMatch**
   - Predicate checks with short-circuiting (pipeline halts early if result is known).

6. **findFirst / findAny**
   - `findFirst`: deterministic (first element in stream).
   - `findAny`: may return any element (useful in parallel streams for efficiency).

7. **toArray**
   - Collects stream elements into an array (`Object[]` or typed array).

8. **min / max**
   - Finds extreme values using a comparator or natural order.

9. **Parallel ordering**
   - Showcases how unordered parallel execution differs between `forEach` and `forEachOrdered`.

10. **Stream reuse limitation**
   - Once consumed by a terminal op, a stream cannot be reused → attempting leads to `IllegalStateException`.

Real-world applications
- **Aggregation pipelines**: Summing, counting, min/max in reporting.
- **Search operations**: Quickly finding first/any matching element.
- **Collections transformation**: Gathering processed data into Lists, Sets, or Maps.
- **Parallelism**: Leveraging short-circuiting and ordering in parallel stream processing.
- **String analysis**: Counting frequency of characters or substrings.
- **Data integrity**: Teaching stream reuse rules prevents runtime exceptions.

Notes
- Complements `IntermediateOps.java`: together, they cover full lifecycle of stream pipelines.
- Emphasizes **lazy vs eager** evaluation boundary.
- Acts as both runnable examples and a learning reference for terminal stream operations.

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

Author: Someshdiwan

JAVA8/StreamsInJAVA/src/TerminalOps.java renamed to Java 8 Crash Course/Java 8 Streams/Intermediate and Terminal Operations/src/TerminalOps.java

@@ -7,50 +7,47 @@
 
 public class TerminalOps {
     public static void main(String[] args) {
-
         List<Integer> list = Arrays.asList(1, 2, 3);
 
-        // 1. collect
+        // 1. collect → gathers stream elements into a collection (List, Set, Map, etc.)
         list.stream().skip(1).collect(Collectors.toList());
-        list.stream().skip(1).toList();
+        list.stream().skip(1).toList(); // Java 16+ shorthand
 
-        // 2. forEach
+        // 2. forEach → performs an action for each element
         list.stream().forEach(x -> System.out.println(x));
 
-        // 3. reduce : Combines elements to produce a single result
+        // 3. reduce → combines elements to produce a single result
         Optional<Integer> optionalInteger = list.stream().reduce(Integer::sum);
-        System.out.println(optionalInteger.get());
-
-        // 4. count
+        System.out.println(optionalInteger.get()); // sum of all elements
 
-        // 5. anyMatch, allMatch, noneMatch
+        // 4. count → returns number of elements in the stream
+        System.out.println("Count: " + list.stream().count());
 
-        boolean b = list.stream().anyMatch(x -> x % 2 == 0);
+        // 5. anyMatch, allMatch, noneMatch → short-circuiting terminal ops
+        boolean b = list.stream().anyMatch(x -> x % 2 == 0);   // any element even?
         System.out.println(b);
-        boolean b1 = list.stream().allMatch(x -> x > 0);
+        boolean b1 = list.stream().allMatch(x -> x > 0);       // all elements > 0?
         System.out.println(b1);
-        boolean b2 = list.stream().noneMatch(x -> x < 0);
+        boolean b2 = list.stream().noneMatch(x -> x < 0);      // none element negative?
         System.out.println(b2);
 
-        // 6. findFirst, findAny
-        System.out.println(list.stream().findFirst().get());
-        System.out.println(list.stream().findAny().get());
-
-        // 7. toArray()
+        // 6. findFirst, findAny → retrieve elements
+        System.out.println(list.stream().findFirst().get());   // always first element
+        System.out.println(list.stream().findAny().get());     // may return any (parallel streams)
 
+        // 7. toArray() → collect elements into an array
         Object[] array = Stream.of(1, 2, 3).toArray();
 
-        // 8. min / max
+        // 8. min / max → compute smallest/largest element
         System.out.println("max: " + Stream.of(2, 44, 69).max((o1, o2) -> o2 - o1));
         System.out.println("min: " + Stream.of(2, 44, 69).min(Comparator.naturalOrder()));
 
-        // 9. forEachOrdered
+        // 9. forEachOrdered → maintains encounter order (important in parallel streams)
         List<Integer> numbers0 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
         System.out.println("Using forEach with parallel stream:");
-        numbers0.parallelStream().forEach(System.out::println);
+        numbers0.parallelStream().forEach(System.out::println); // order not guaranteed
         System.out.println("Using forEachOrdered with parallel stream:");
-        numbers0.parallelStream().forEachOrdered(System.out::println);
-
+        numbers0.parallelStream().forEachOrdered(System.out::println); // maintains order
 
 
         // Example: Filtering and Collecting Names
@@ -65,19 +62,20 @@ public static void main(String[] args) {
         List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
         System.out.println(integers.stream().reduce(Integer::sum).get());
 
-        // Example:  Counting Occurrences of a Character
+        // Example: Counting Occurrences of a Character
         String sentence = "Hello world";
-        System.out.println(sentence.chars().filter(x -> x == 'l').count());
+        System.out.println(sentence.chars().filter(x -> x == 'l').count()); // count 'l'
 
-        // Example
+        // Example: Stream Reuse Limitation
         // Streams cannot be reused after a terminal operation has been called
         Stream<String> stream = names.stream();
         stream.forEach(System.out::println);
-//        List<String> list1 = stream.map(String::toUpperCase).toList(); // exception
-
-        // stateful & stateless
-
-
+        // List<String> list1 = stream.map(String::toUpperCase).toList(); // throws IllegalStateException
 
+        // NOTE:
+        // - Terminal operations = trigger execution of the stream pipeline.
+        // - Once terminal op is invoked, the stream is consumed and cannot be reused.
+        // - Some terminal ops are "short-circuiting" (anyMatch, findFirst, etc.).
+        // - Distinction: stateful Vs stateless operations
     }
-}
+}