feat(streams): demonstrate advanced Stream API operations with mapping, filtering, sorting, and limiting

What
- Added `Test.java` showcasing various Stream API transformations and queries on a sample list of integers.
- Implemented multiple stream pipelines:
  1. **Square numbers**
     - Used `map(x -> x * x)` to compute squares.
     - Collected into a new list for printing.

  2. **Filter evens**
     - Applied `filter(x -> x % 2 == 0)` to extract only even numbers.

  3. **Divide evens by 2**
     - First approach: filter → collect → map over filtered list.
     - Alternative: filter + map in one pipeline.
     - Showed both styles for clarity.

  4. **Remove duplicates**
     - Added `.distinct()` after mapping to eliminate repeated results.

  5. **Sorting**
     - Natural order sorting with `.sorted()`.
     - Custom comparator `(b - a)` for descending order sorting.

  6. **Limit and Skip**
     - Used `.limit(4)` to restrict output.
     - Chained `.skip(1)` to drop the first element after limiting.

Why
- Provides a **comprehensive walkthrough** of commonly used Stream API features:
  - Transformation (map)
  - Filtering (filter)
  - Deduplication (distinct)
  - Sorting (sorted + custom comparator)
  - Subsetting (limit + skip)
- Useful as a reference for learning both **stateless** (map, filter) and **stateful** (distinct, sorted, limit, skip) operations.

Logic
1. **Mapping** → transforms data (square numbers, divide evens by 2).
2. **Filtering** → keeps only desired values (even numbers).
3. **Distinct** → removes duplicates, requires remembering seen values.
4. **Sorting**
   - Natural order = ascending.
   - Custom comparator = descending order (b - a).
5. **Limit + Skip** → subsetting stream results (pagination-like behavior).
6. Chaining operations shows how pipelines can be composed flexibly.

Key Takeaways
✔ `map` and `filter` are stateless (process elements independently).
✔ `distinct`, `sorted`, `limit`, `skip` are stateful (need global state or buffering).
✔ Stream pipelines can be tailored for transformation, deduplication, sorting, and subsetting.
✔ Custom comparators and chaining allow building powerful, expressive queries.
✔ Order of operations matters: filtering before mapping reduces unnecessary work.

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

Author: Someshdiwan

Java 8 Crash Course/Java 8 Streams/StreamOperations/src/Test.java

@@ -0,0 +1,83 @@
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Test {
+    public static void main(String[] args) {
+        List<Integer> list = Arrays.asList(1,2,3,4,5,6,6,7,8,8,9,4444,5,6,7,7,7,73454,0,1,1);
+
+        // Find square of all the numbers in the list.
+        List<Integer> squaredList =
+                list.stream()
+                        .map(x -> x * x) // map() transforms each element → x^2
+                        .collect(Collectors.toList());
+        System.out.println("Squares: " + squaredList);
+
+
+        // Printing even numbers from the list.
+        List<Integer> FilteredList =
+                list.stream().
+                        filter(x -> x % 2 == 0).
+                        collect(Collectors.toList());
+        //x -> x % 2 == 0 predicate likha hai.
+        System.out.println(FilteredList);
+
+
+        // Every even number divide by 2.
+        List<Integer> MappedList =
+                FilteredList.stream().
+                        map(x -> x / 2).
+                        collect(Collectors.toList());
+        System.out.println(MappedList);
+
+        List<Integer> MappedAlternative =
+                list.stream().
+                        filter(x -> x % 2 == 0).
+                        map(x -> x / 2).
+                        collect(Collectors.toList());
+        System.out.println(MappedAlternative);
+
+        List<Integer> MappedDistinct =
+                list.stream().
+                filter(x -> x % 2 == 0).
+                        map(x -> x / 2).
+                        distinct().
+                        collect(Collectors.toList());
+        System.out.println(MappedDistinct);
+
+        List<Integer> MappedSorted =
+                list.stream().
+                filter(x -> x % 2 == 0).
+                        map(x -> x / 2).
+                        distinct().sorted().
+                        collect(Collectors.toList());
+        System.out.println(MappedSorted);
+
+        List<Integer> MappedSortToYourOwnNotNaturalOrderSorting =
+                list.stream().
+                filter(x -> x % 2 == 0).map(x -> x / 2).
+                distinct().sorted((a, b) -> (b - a)).
+                collect(Collectors.toList());
+
+        System.out.println(MappedSortToYourOwnNotNaturalOrderSorting + "Custom Sorting");
+
+        List<Integer> CustomSort =
+                list.stream().
+                        filter(x -> x % 2 == 0).map(x -> x / 2).
+                        distinct().sorted((a, b) -> (b - a)).
+                        limit(4).
+                        collect(Collectors.toList());
+
+        System.out.println(CustomSort + "Custom Sorting Only show 4 element");
+
+        List<Integer> Limit5 =
+                list.stream().
+                        filter(x -> x % 2 == 0).map(x -> x / 2).
+                        distinct().sorted((a, b) -> (b - a)).
+                        limit(4).
+                        skip(1).
+                        collect(Collectors.toList());
+
+        System.out.println(Limit5);
+    }
+}