feat(streams-api): add CollectorsDemo showcasing advanced collectors usage

What
- Introduced `CollectorsDemo` class demonstrating practical use-cases of the Java Streams API and Collectors.
- Added multiple examples:
  1. Grouping elements by string length.
  2. Counting word occurrences in a sentence.
  3. Partitioning numbers into even/odd.
  4. Summing values from a map.
  5. Creating maps with transformations (uppercase → length).
  6. Counting frequency of words using `toMap` with merge function.
- Each example annotated with input, logic, and expected result.

Why
- Collectors are central to data aggregation and transformation in modern Java applications.
- Provides clear, practical demonstrations beyond simple `toList()` usage.
- Helps developers understand declarative data processing vs imperative loops.

Logic
1. **Grouping by length**
   - `Collectors.groupingBy(String::length)` → Map<Integer, List<String>> where key = length.
   - Example: ["Anna", "Bob", "Alexander"] → {3=[Bob], 4=[Anna], 9=[Alexander]}.

2. **Counting word occurrences**
   - Sentence split into words → grouped by word → count aggregated with `Collectors.counting()`.
   - Efficient for computing frequency tables.

3. **Partitioning numbers**
   - `Collectors.partitioningBy(x -> x % 2 == 0)` → splits into two lists:
     true = evens, false = odds.
   - Example: [1,2,3,4,5,6] → {true=[2,4,6], false=[1,3,5]}.

4. **Summing values**
   - Demonstrated two ways:
     - `reduce(Integer::sum)` for manual accumulation.
     - `Collectors.summingInt(x -> x)` for cleaner summation.
   - Example: {Apple=10, Banana=20, Orange=15} → 45.

5. **Creating a map with transformations**
   - `Collectors.toMap(keyMapper, valueMapper)` builds maps directly from streams.
   - Example: ["Apple", "Banana"] → {APPLE=5, BANANA=6}.

6. **Counting frequency using merge function**
   - `Collectors.toMap(k -> k, v -> 1, (x,y)->x+y)` handles duplicate keys by summing counts.
   - Example: ["apple","banana","apple"] → {apple=2, banana=1}.

Real-life applications
- **Analytics**: word frequency counters, log aggregations, grouping by attributes.
- **Reporting systems**: partitioning datasets (active/inactive users, passed/failed tests).
- **E-commerce apps**: summing cart values, grouping orders by customer, counting product sales.
- **Data transformation pipelines**: converting raw text or collections into structured maps.

Notes
- `groupingBy` → flexible grouping by classifier function.
- `partitioningBy` → boolean-based split, always returns two groups.
- `toMap` requires merge function when duplicates exist.
- `Collectors.summingInt` is cleaner and safer than manual reduce for summation.

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

Author: Someshdiwan

JAVA8/JavaCollectorsAPI/src/CollectorsDemo.java

@@ -0,0 +1,75 @@
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class CollectorsDemo {
+    public static void main(String[] args) {
+        /* Collectors is a utility class, provides a set of methods to create common collectors. */
+
+        /* Example 1: Collecting Names by Length
+        l1.stream().collect(Collectors.groupingBy(String::length)):
+        - Group names based on their length.
+        - Key: length of string.
+        - Value: list of names having that length.
+        Input: ["Anna", "Bob", "Alexander", "Brian", "Alice"]
+        Result: {3=[Bob], 4=[Anna], 5=[Brian, Alice], 9=[Alexander]}  */
+        List<String> l1 = Arrays.asList("Anna", "Bob", "Alexander", "Brian", "Alice");
+        System.out.println(l1.stream().collect(Collectors.groupingBy(String::length)));
+
+
+        /* Example 2: Counting Word Occurrences
+        Arrays.stream(sentence.split(" ")).collect(Collectors.groupingBy(...)):
+        - Key: unique word.
+        - Value: how many times that word occurs.
+        Input: "hello world hello java world"
+        Result: {hello=2, world=2, java=1} */
+        String sentence = "hello world hello java world";
+        System.out.println(Arrays.stream(sentence.split(" ")).collect(Collectors.groupingBy(x -> x, Collectors.counting())));
+
+
+        /* Example 3: Partitioning Even and Odd Numbers
+           l2.stream().collect(Collectors.partitioningBy(x -> x % 2 == 0)):
+           - Predicate: x % 2 == 0 (true for even, false for odd).
+           - Splits elements into two groups:
+             true → even numbers, false → odd numbers.
+           Input: [1, 2, 3, 4, 5, 6]
+           Result: {false=[1, 3, 5], true=[2, 4, 6]} */
+        List<Integer> l2 = Arrays.asList(1, 2, 3, 4, 5, 6);
+        System.out.println(l2.stream().collect(Collectors.partitioningBy(x -> x % 2 == 0)));
+
+
+        /* Example 4: Summing Values in a Map
+           items.values().stream().reduce(Integer::sum):
+           - Reduce operation to sum values manually.
+           items.values().stream().collect(Collectors.summingInt(x -> x)):
+           - Built-in collector to sum integer values.
+           Input Map: {Apple=10, Banana=20, Orange=15}
+           Result: 45 */
+        Map<String, Integer> items = new HashMap<>();
+        items.put("Apple", 10);
+        items.put("Banana", 20);
+        items.put("Orange", 15);
+        System.out.println(items.values().stream().reduce(Integer::sum));
+        System.out.println(items.values().stream().collect(Collectors.summingInt(x -> x)));
+
+
+        /* Example 5: Creating a Map from Stream Elements
+           fruits.stream().collect(Collectors.toMap(...)):
+           - Key: fruit name in uppercase (x -> x.toUpperCase()).
+           - Value: length of fruit name (x -> x.length()).
+           Input: ["Apple", "Banana", "Cherry"]
+           Result: {APPLE=5, BANANA=6, CHERRY=6} */
+        List<String> fruits = Arrays.asList("Apple", "Banana", "Cherry");
+        System.out.println(fruits.stream().collect(Collectors.toMap(x -> x.toUpperCase(), x -> x.length())));
+
+
+        /* Case 2: Counting Frequency of Words
+           words2.stream().collect(Collectors.toMap(...)):
+           - Key: the word itself (k -> k).
+           - Value: initial count = 1 (v -> 1).
+           - Merge function: (x, y) -> x + y → sum frequencies.
+           Input: ["apple", "banana", "apple", "orange", "banana", "apple"]
+           Result: {apple=3, banana=2, orange=1} */
+        List<String> words2 = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple");
+        System.out.println(words2.stream().collect(Collectors.toMap(k -> k, v -> 1, (x, y) -> x + y)));
+    }
+}