docs(io): add detailed explanation of Piped Streams for inter-thread communication

What
- Documented concept of **Piped Streams in Java** (PipedInputStream + PipedOutputStream).
- Covered:
  - Definition and purpose (inter-thread data communication).
  - Core components and their roles.
  - Step-by-step working mechanism (producer → output stream → internal buffer → input stream → consumer).
  - Blocking behavior when buffer is empty/full.
  - Stream connection requirement using `.connect()`.
- Listed **advantages** (efficiency, no shared memory, producer-consumer handling).
- Highlighted **disadvantages** (blocking, exception handling, limited buffer).

Why
- Piped Streams are a foundational Java I/O mechanism for **producer-consumer problems** and inter-thread communication.
- Unlike shared memory approaches, they allow **direct streaming of data between threads**.
- Understanding their blocking nature and buffer limitations is crucial for writing safe concurrent programs.

Logic
1. **Producer writes to PipedOutputStream**
   - Data is stored in the pipe’s internal buffer.
   - If buffer is full → producer thread blocks until space is available.

2. **Consumer reads from PipedInputStream**
   - Retrieves bytes from the internal buffer.
   - If buffer is empty → consumer thread blocks until producer writes data.

3. **Connection**
   - Must explicitly connect `PipedInputStream` with `PipedOutputStream` via `.connect()` before usage.
   - Once connected, data flows seamlessly across threads.

4. **Thread Synchronization**
   - The blocking nature implicitly synchronizes producer and consumer threads.
   - Prevents data corruption without needing explicit locks.

Real-world applications
- **Producer-Consumer problems**: logging systems, event pipelines, data streaming tasks.
- **Multithreaded processing**: one thread generates data (producer), another processes it (consumer).
- **Simulation of Unix-like pipes** in Java programs.
- **Messaging systems** within applications where lightweight communication is needed without shared variables.

Notes
- Buffer size is fixed (default 1024 bytes unless specified).
- Exceptions (e.g., IOException, Pipe broken) must be handled to avoid thread crashes.
- Avoid connecting multiple input/output streams to the same pipe — unsupported and error-prone.
- Works only for **intra-process thread communication** (not across JVMs or machines).

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

Author: Someshdiwan

JAVA8/StreamsInJAVA/PrimitiveStreams/src/Primitive streams various application.txt

@@ -0,0 +1,106 @@
+Primitive Streams in Java
+
+Primitive streams are specialized versions of the Java Streams API that deal specifically with primitive data
+types (such as int, long, and double).
+
+They offer several benefits and are widely used in various application layers.
+
+---
+
+What Are Primitive Streams?
+
+- Specialized Streams:
+  Primitive streams—like IntStream, LongStream, and DoubleStream — are designed to handle primitive data types
+  directly.
+  This avoids the performance overhead associated with autoboxing and unboxing that occurs with their object
+  counterparts (e.g., Stream<Integer>).
+
+- Built-In Methods:
+  They come with built-in operations specifically tailored for numerical computations, such as sum(), average(),
+  min(), max(), and summaryStatistics(), which streamline common tasks in numerical data processing.
+
+---
+
+Benefits in Software Development
+
+- Performance Optimization:
+  By avoiding the need to convert between primitive types and their wrapper classes, primitive streams reduce
+  memory overhead and improve processing speed—crucial in performance-sensitive applications.
+
+- Enhanced Readability and Conciseness:
+  They allow developers to write more declarative and succinct code when performing numerical computations,
+  similar to how standard streams improve the clarity of data transformations.
+
+- Specialized Numeric Operations:
+  The APIs provide methods that are specifically optimized for numeric data, which can simplify tasks like
+  calculating statistics or iterating over ranges of numbers.
+
+---
+
+Real-World Applications
+
+1. Back-End Data Processing
+   - Statistical Analysis and Reporting:
+     In enterprise applications, primitive streams are often used to compute statistics
+     (e.g., total sales, averages, or minimum/maximum values) from large datasets fetched from databases.
+
+   - Financial Systems:
+     Applications dealing with high-frequency financial data leverage DoubleStream or LongStream for fast
+     calculations of metrics such as moving averages or risk assessments.
+
+2. Data Analytics and Scientific Computing
+   - Large-Scale Numerical Computations:
+     Systems that process sensor data, perform simulations, or execute complex mathematical calculations can
+     benefit from the performance improvements of primitive streams.
+
+   - Real-Time Data Processing:
+     In scenarios like monitoring or analytics dashboards, primitive streams efficiently aggregate numeric
+     data in real time.
+
+3. Utility Libraries and Middleware
+   - Custom Numeric Utilities:
+     Developers often write helper methods using primitive streams for common operations on numeric arrays,
+     which are then reused across different parts of the application.
+
+   - Parallel Processing:
+     When working with massive numeric datasets, primitive streams can be parallelized to leverage multicore
+     processors effectively, thereby improving throughput in high-load environments.
+
+---
+
+Example Code
+
+// Compute the sum of numbers from 1 to 100 using IntStream
+import java.util.stream.IntStream;
+
+public class PrimitiveStreamExample {
+    public static void main(String[] args) {
+        int sum = IntStream.rangeClosed(1, 100).sum();
+        System.out.println("Sum from 1 to 100: " + sum);
+    }
+}
+
+Explanation:
+This code snippet uses IntStream.rangeClosed() to create a stream of integers from 1 to 100,
+then directly computes the sum using the sum() method—demonstrating the concise and efficient processing that
+primitive streams provide.
+
+---
+
+Integration with Other Java APIs
+
+- Conversion:
+  Primitive streams can be converted to their boxed counterparts (e.g., converting an IntStream to a
+  Stream<Integer>) using the boxed() method, which is useful when you need to interact with APIs that
+  require objects.
+
+- Aggregation and Reduction:
+  They integrate seamlessly with the Collectors API, particularly when you need to generate statistical
+  summaries or perform custom reductions on numeric data.
+
+---
+
+In summary:
+Primitive streams are an essential tool in Java for efficient numerical data processing.
+They are particularly beneficial in back-end data processing, analytics, scientific computing, and
+performance-critical applications, providing both performance improvements and cleaner, more maintainable code.