feat(streams): add factorial computation and filter-peek-count demo using Java Streams

What
- Added `FactorialDemo`:
  - Demonstrates computing factorial using Java 8 Streams (`IntStream.rangeClosed` + `reduce`).
  - `printFactorial(int n)` → calculates factorial by reducing the range [1..n] with multiplication.
  - `solve(int n)` wrapper method introduced for readability.
  - Prints factorial of `6` → output `720`.

- Added `StreamDemo`:
  - Demonstrates filtering, peeking, and counting with streams.
  - Input list: ["a", "b", "c", "d", "e"].
  - `.filter(s -> s.compareTo("c") > 0)` → keeps only elements after "c" alphabetically (`"d"`, `"e"`).
  - `.peek(System.out::println)` → prints filtered elements (side effect for debugging).
  - `.count()` → terminal operation that counts elements post-filter (expected = `2`).
  - Prints elements `"d"`, `"e"`, then the count `2`.

Why
- To illustrate **two key stream use-cases**:
  1. **Mathematical computation (factorial)** using `reduce` and `IntStream`.
  2. **Data filtering + debugging + aggregation** with filter, peek, and count.
- Reinforces understanding of lazy evaluation (peek prints only when terminal op is triggered).
- Shows declarative programming style vs imperative loops.

Logic
1. **FactorialDemo**
   - Stream pipeline: `IntStream.rangeClosed(1, n)` → sequence [1..n].
   - Reduce operation: `(a, b) -> a * b` multiplies accumulatively.
   - Initial identity = `1` ensures neutral start for multiplication.
   - For n=6 → factorial = `1*2*3*4*5*6 = 720`.

2. **StreamDemo**
   - List of strings converted to stream.
   - Filter keeps strings alphabetically greater than `"c"`.
   - Peek prints elements after filter (`"d"`, `"e"`).
   - Count triggers evaluation, resulting in `2`.

Key Takeaways
- Streams allow **functional-style computation** (factorial via reduce).
- Intermediate operations (`filter`, `peek`) are lazy → only run when terminal op (`count`) is called.
- `peek()` is invaluable for debugging pipelines without breaking them.
- Terminal operations consume the stream; reuse is not allowed.

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

Author: Someshdiwan

JAVA8/StreamsInJAVA/src/StreamExample.java renamed to Java 8 Crash Course/Java 8 Streams/src/Stream/StreamDemo.java

@@ -1,7 +1,9 @@
+package Stream;
+
 import java.util.Arrays;
 import java.util.List;
 
-public class StreamExample {
+public class StreamDemo {
     public static void main(String[] args) {
         List<String> list = Arrays.asList("a", "b", "c", "d", "e");
 
@@ -17,17 +19,23 @@ public static void main(String[] args) {
 /*
 This question tests your understanding of Java Streams, specifically filter, peek, and count.
 
-The problem asks for the output of a given Java code snippet. Let's break down the code step by step:
+The problem asks for the output of a given Java code snippet.
 
 List<String> list = Arrays.asList("a", "b", "c", "d", "e"); - This creates a List of strings.
 .stream() - This converts the list into a stream.
-.filter(s -> s.compareTo("c") > 0) - This filters the stream, keeping only elements where the comparison with "c" is greater than 0. s.compareTo("c") > 0 means that string s comes after "c" alphabetically. So, "d" and "e" will pass this filter.
-.peek(System.out::println) - This is an intermediate operation that allows you to perform an action on each element as it passes through the stream. In this case, it will print each element that has passed the filter.
-.count() - This is a terminal operation that counts the number of elements in the stream after all the intermediate operations have been applied.
+.filter(s -> s.compareTo("c") > 0) - This filters the stream, keeping only elements where the
+comparison with "c" is greater than 0.
+s.compareTo("c") > 0 means that string s comes after "c" alphabetically. So, "d" and "e" will pass this filter.
+.peek(System.out::println) - This is an intermediate operation that allows you to perform an action on each element
+as it passes through the stream.
+
+In this case, it will print each element that has passed the filter.
+.count() - This is a terminal operation that counts the number of elements in the stream after all the
+intermediate operations have been applied.
 
 Based on this analysis, the elements "d" and "e" will pass the filter. The peek operation will then print "d" and then "e".
 
-Finally, the count operation will return the number of elements that passed the filter, which is 2. The last System.out.println(count); will print this count.
+Finally, the count operation will return the number of elements that passed the filter, which is 2.
 
-Therefore, the output will be "d", followed by "e", followed by "2".
-*/
+The last System.out.println(count); will print this count.
+*/