docs(core-concepts): add overview of Streams, Collections Framework, and Generics

What
- Added a detailed documentation file covering three foundational Java concepts:
  1. Streams → declarative, functional data processing with filter/map/reduce and parallelism.
  2. Collections Framework → core data structures (List, Set, Map, Queue) and their integration in back-end, front-end, and frameworks.
  3. Generics → type-safety, reusability, and readability improvements with generic classes/interfaces.
- Included structured sections:
  - Concept explanation
  - Practical applications
  - Real-world usage across back-end, microservices, UI, and middleware.
- Provided a concise summary that positions these three concepts as the backbone of scalable Java development.

Why
- These three concepts are central to modern Java programming across domains.
- Developers often use them together (e.g., Collections hold data, Streams process it, Generics enforce type safety).
- A unified overview makes it easier to understand how they interconnect and why mastering them is essential for enterprise-grade applications.

Logic
1. **Streams**
   - Emphasized functional, declarative style over imperative loops.
   - Highlighted back-end data manipulation, parallel computation, and event/log pipelines.
   - Showed relevance in high-throughput systems like Spring Boot services or analytics.

2. **Collections Framework**
   - Identified as the backbone of Java applications.
   - Explained usage in back-end (DB results, caching), front-end/mobile (UI state, adapters), and frameworks (Spring, Hibernate).
   - Reinforced importance as building blocks for nearly all Java data-handling code.

3. **Generics**
   - Explained compile-time type safety preventing runtime ClassCastException.
   - Showed reusability via type-safe repositories, DTOs, and custom utilities.
   - Clarified benefits of reduced boilerplate and increased readability.

4. **Real-World Applications**
   - Connected Streams, Collections, and Generics into enterprise workflows:
     - Back-end data processing (Collections + Streams).
     - Microservices aggregation (Streams + Generics for DTOs).
     - UI/mobile apps (Collections + Generics for model binding).
     - Utility libraries (all three for flexibility and safety).

Real-life applications
- Enterprise back-end: Streams filter/aggregate DB records, Collections cache them, Generics enforce DTO typing.
- Microservices: Streams combine service results, Generics enable reusable interfaces across APIs.
- UI/Mobile apps: Collections model UI data, Streams transform it, Generics prevent runtime casting errors.
- Middleware/utility libraries: Provide type-safe, reusable APIs built on Collections and Generics.

Notes
- ✔ Streams = declarative, functional pipelines for data.
- ✔ Collections = robust, reusable data structures.
- ✔ Generics = compile-time safety + reusable APIs.
- Together, these form the core triad for efficient, scalable, and maintainable Java systems.

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

Author: Someshdiwan

Java 8 Crash Course/Java Collectors API/src/Overview: Streams, Collections Framework, and Generics.txt

@@ -0,0 +1,70 @@
+Overview: Streams, Collections Framework, and Generics:
+
+Java Streams
+------------
+- Declarative Data Processing:
+  Functional, chainable operations (filter, map, reduce) instead of verbose loops.
+
+- Back-End Data Manipulation:
+  Used in Spring Boot / server apps to filter, transform, and aggregate DB or API data.
+
+- Parallel Processing:
+  Execute in parallel → efficient for large datasets and CPU-heavy tasks.
+
+- Event & Log Processing:
+  Ideal for pipelines like log analysis, event filtering, and computing summaries.
+
+--------------------------------------------------------
+
+Java Collections Framework
+--------------------------
+- Core Data Structures:
+  Provides List, Set, Map, Queue → backbone of most Java applications.
+
+- Wide Applicability:
+  * Back-End: Store DB results, cache business logic data.
+  * Front-End (JavaFX/Android): Manage UI states, adapters, and session data.
+  * Framework Integration: Heavily used in Spring, Hibernate, and APIs.
+
+--------------------------------------------------------
+
+Generics
+--------
+- Type Safety:
+  Prevents runtime errors by enforcing compile-time checks (e.g., List<String>).
+
+- Reusable Components:
+  Enables generic repositories, utility classes, and type-safe APIs.
+
+- Readability & Maintenance:
+  Eliminates casting, improves clarity, reduces boilerplate.
+
+- Wide-Ranging Impact:
+  * Frameworks/Libraries: Type-safe utilities and collections.
+  * Custom Data Structures: Generic classes define clear type contracts.
+
+--------------------------------------------------------
+
+Real-World Applications
+-----------------------
+- Enterprise Back-End:
+  Collections hold DB records, Streams process them, Generics ensure type safety.
+
+- Microservices:
+  Aggregate multiple service results with streams; generics provide reusable DTOs and interfaces.
+
+- UI & Mobile Apps:
+  Collections manage models, Streams simplify transformations, Generics enforce type checks.
+
+- Utility & Middleware:
+  Custom libraries use Collections for data, Generics for flexible APIs.
+
+--------------------------------------------------------
+
+Summary
+-------
+✔ Streams → Modern, functional data processing.
+✔ Collections → Robust, reusable data structures.
+✔ Generics → Type safety + reusability.
+
+Together = foundation for efficient, scalable, and maintainable Java applications (front-end & back-end).