Updated base #10
Merged
Updated base #10
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
and methods via reflection This demo showcases how to use Java Reflection API to inspect the internal structure of the ArrayList class. Key highlights: • Obtains the Class object for java.util.ArrayList using ArrayList.class. • Retrieves all declared constructors with getDeclaredConstructors(). • Retrieves all declared methods with getDeclaredMethods(). • Iterates over constructors and methods, printing their names. Why this is useful: • Demonstrates reflection capabilities for runtime class inspection. • Helps understand how many constructors and methods exist inside core library classes like ArrayList. • Useful for debugging, framework design, and meta-programming tasks where behavior adapts based on runtime class analysis. Output: - Prints the list of all constructor signatures of ArrayList. - Prints the names of all methods (public, protected, private, and package-private declared within ArrayList). Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
…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]>
…with Java examples What - Documented the concept of **Declarative Programming** vs **Imperative Programming**. - Highlighted key characteristics: - Focus on *what* to achieve, not *how* to achieve it. - High-level abstraction with less boilerplate code. - Execution strategy left to underlying system (e.g., SQL engine, Streams). - Provided concrete examples across multiple domains: - **SQL** → `SELECT * FROM students WHERE marks > 90` (declarative query). - **Java Streams** → `list.stream().filter(...).map(...).toList()` (functional transformations). - **HTML/CSS** → structure and styling declaratively described. - Outlined benefits: - Conciseness, readability, maintainability. - Easier parallelization via declarative APIs. - Added **Java-specific comparison**: - Imperative sum of even numbers (loops + conditions). - Declarative sum using Streams API (`filter`, `mapToInt`, `sum`). Why - Declarative programming is central to modern Java (Streams, Lambdas, functional style). - Developers often confuse *control flow* with *business logic*; declarative style separates the two. - This doc clarifies when and why declarative approaches are preferred in enterprise apps. Logic 1. **Definition** - Declarative = specify outcome, not steps. - Contrasted with imperative = specify exact flow (loops, state changes). 2. **Key Characteristics** - Abstraction of execution. - Focus on results instead of algorithmic details. - Reduction of verbosity and control structures. 3. **Examples** - SQL → declare query logic without procedural fetch. - Streams → pipelines describe transformation, not iteration. - HTML → structure declaration, not rendering process. 4. **Java Focus** - Streams API embodies declarative patterns (map/filter/reduce). - Shows improved readability and parallelization compared to traditional loops. Real-life applications - **Database queries (SQL)**: write intent-driven queries, let DBMS handle execution plan. - **Back-end APIs (Java Streams)**: declarative transformations for business rules. - **UI layer (HTML/CSS)**: declaratively specify layout and style, browsers handle rendering. - **Parallel data processing**: declarative pipelines allow frameworks to optimize multithreaded execution. Notes - Declarative ≠ “no control,” but rather offloading control to libraries/engines. - Imperative code is sometimes necessary for low-level optimization, but declarative style is preferred for clarity. - Java’s `Stream.parallel()` demonstrates how declarative style enables automatic performance improvements. Signed-off-by: https://github.com/Someshdiwan <[email protected]>
…am, LongStream, DoubleStream) What - Documented **Primitive Streams in Java** and their role in numerical data processing. - Covered: - Definition and difference from object-based streams. - Specialized types: IntStream, LongStream, DoubleStream. - Built-in numeric methods (sum, average, min, max, summaryStatistics). - Benefits: performance optimization, readability, specialized numeric APIs. - Explained real-world applications across back-end systems, analytics, financial apps, and middleware. - Provided example using IntStream.rangeClosed(1, 100).sum(). - Added notes on integration with other APIs (boxed conversion, Collectors aggregation). Why - Standard `Stream<Integer>` incurs autoboxing/unboxing overhead, reducing efficiency in numeric-heavy workloads. - Primitive Streams solve this by working directly with primitives (int, long, double). - They are critical in performance-sensitive domains such as analytics, finance, and real-time monitoring. - Understanding their role ensures developers can write cleaner, faster, and more maintainable numeric pipelines. Logic 1. **Specialized Stream Types** - `IntStream` → operations on int values. - `LongStream` → operations on long values. - `DoubleStream` → operations on double values. 2. **Performance Advantage** - Avoids autoboxing/unboxing (`int ↔ Integer`). - Reduces memory usage and GC pressure. - Better suited for large-scale numeric operations. 3. **Built-in Numeric Methods** - Directly provides `sum()`, `average()`, `min()`, `max()`, and `summaryStatistics()`. - Eliminates need for manual reduction/aggregation logic. 4. **Integration** - `boxed()` → converts primitive streams to object streams when APIs require `Stream<T>`. - Works seamlessly with Collectors for statistical reporting. Real-world applications - **Back-End Processing**: Sales aggregation, DB report generation. - **Financial Systems**: Risk models, moving averages, high-frequency trading data. - **Analytics/Scientific Computing**: Sensor data, simulations, dashboards. - **Middleware/Utilities**: Reusable numeric helper APIs, parallel data crunching. Notes - Prefer primitive streams for numeric-heavy workloads. - Use `parallel()` when large datasets benefit from multicore processing. - Convert to boxed streams only when integration requires object types. - Leverage `summaryStatistics()` for concise statistical reporting. Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Java. Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
LF in the repo. now Windows file support can clone repo. Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Signed-off-by: https://github.com/Someshdiwan <[email protected]>
banner: continuous loop animation + clickable link in README.md. Signed-off-by: https://github.com/Someshdiwan <[email protected]>
Someshdiwan
temporarily deployed
to
github-pages
GitHub Actions
Inactive
Someshdiwan
temporarily deployed
to
github-pages
GitHub Actions
Inactive
Someshdiwan
temporarily deployed
to
github-pages
GitHub Actions
Inactive
Someshdiwan
temporarily deployed
to
github-pages
GitHub Actions
Inactive
Someshdiwan
temporarily deployed
to
github-pages
GitHub Actions
Inactive
Someshdiwan
temporarily deployed
to
github-pages
GitHub Actions
Inactive
Someshdiwan
temporarily deployed
to
github-pages
GitHub Actions
Inactive
Someshdiwan
temporarily deployed
to
github-pages
GitHub Actions
Inactive
Someshdiwan
temporarily deployed
to
github-pages
GitHub Actions
Inactive
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
ok