feat: add BufferedInputStreamsExample to demonstrate advanced Java I/O concepts

WHAT:
- Implemented `BufferedInputStreamsExample` showing how `BufferedInputStream` works on top of `FileInputStream`.
- Demonstrated:
  • Sequential character reads.
  • Using `mark(int readlimit)` to mark a position.
  • Using `reset()` to rewind the stream back to the marked position.
- Added optional checks with `markSupported()` to highlight differences between `FileInputStream` and `BufferedInputStream`.

WHY:
- `FileInputStream` reads one byte at a time directly from disk → slower for frequent small reads.
- `BufferedInputStream` improves performance by maintaining an internal buffer, reducing direct disk access.
- `mark()` and `reset()` enable lookahead and re-reading without reopening the file, critical in parsing scenarios.

HOW:
1. Opened file via `FileInputStream`.
2. Wrapped it in `BufferedInputStream` to enable buffered operations.
3. Read characters, set a mark, consumed more data, and then reset to re-read.
4. Provided commented examples showing `markSupported()` and full stream reads.

REAL-WORLD USE CASES:
- Text or binary file parsers (XML, JSON, CSV) where peeking ahead is required.
- Media players (buffering ensures smooth playback).
- Network data reading (efficient buffering of incoming streams).
- Large file reading with reduced I/O calls.

LEARNING CONTEXT:
- This is part of **Advanced Java Programming**, covering Java I/O streams in depth.
- Builds on core concepts (`FileInputStream`) and extends to buffered streams, mark/reset mechanics, and performance tuning.

NOTES:
- Always close streams in production code (use try-with-resources for safety).
- Buffered streams are part of the `java.io` package and complement other classes like `BufferedOutputStream`.

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

Author: Someshdiwan

Section23JavaIOStreams/src/BufferedInputStreamsExample.java

@@ -3,8 +3,10 @@
 
 public class BufferedInputStreamsExample {
     public static void main(String[] args)throws Exception {
-        FileInputStream fis = new FileInputStream("C://Users//somes//Downloads//JAVA SE//Section23JavaIOStreams//src//MyJAVA//BufferTest.txt");
-        BufferedInputStream bis = new BufferedInputStream(fis); // Creating a connection: bis is linked to fis.
+        FileInputStream fis = new FileInputStream("/Users/somesh/Java SE/JavaEvolution-Learning-Growing-Mastering/Section23JavaIOStreams/src/MyJAVA/BufferTest.txt");
+
+        BufferedInputStream bis = new BufferedInputStream(fis);
+        // Creating a connection: bis is linked to fis.
 
         System.out.print((char)bis.read());
         System.out.print((char)bis.read());
@@ -20,20 +22,63 @@ public static void main(String[] args)throws Exception {
 
         // Demonstrating that BufferedInputStream holds data in a temporary memory area.
 
-        /*System.out.println("File "+fis.markSupported());
-        System.out.println("Buffer "+bis.markSupported());
+        /*
+        System.out.println("File " + fis.markSupported());
+        System.out.println("Buffer " + bis.markSupported());
         */
 
-        /*int x;
+        /* int x;
         while((x=bis.read())!=-1)
         {
             System.out.print((char)x);
-        }*/
-
+        }
+        */
     }
 }
 
-// File: BufferTest.txt (Using FileInputStream, we can read data from a file)
-// BufferedInputStream provides a temporary memory buffer that holds data for efficient reading.
-// Similar to how a video buffers while streaming to match source and destination speeds.
-// For writing data to a file, FileOutputStream is used.
+/*
+File: BufferTest.txt (Using FileInputStream, we can read data from a file) BufferedInputStream provides a temporary
+memory buffer that holds data for efficient reading.
+Similar to how a video buffers while streaming to match source and destination speeds.
+For writing data to a file, FileOutputStream is used.
+
+1. FileInputStream (fis):
+   - Directly file se data read karta hai.
+   - But har read() call disk se hota hai → slow.
+
+2. BufferedInputStream (bis):
+   - Ek temporary memory buffer use karta hai (default ~8KB).
+   - File se ek block data le aata hai, phir us buffer se read hota hai → fast.
+   - Example: YouTube video buffering (source slow ho sakta hai, but playback smooth hota hai).
+
+3. Important Methods:
+   - read() → ek byte (int return karta hai) read karta hai.
+   - mark(int readlimit) → current position ko mark karta hai.
+   - reset() → stream ko wapas marked position pe le aata hai.
+   - markSupported() → check karta hai ki mark–reset support karta hai ya nahi.
+
+4. Code Explanation:
+   -  Pehle 3 characters read kiye.
+   - `mark(10)` lagaya (stream ka position save ho gaya).
+   - Next 2 characters read kiye.
+   - `reset()` kiya → pointer wapas marked position pe aagaya.
+   - Fir se wahi 2 characters dobara read hue.
+
+5. Output Behaviour (assuming file BufferTest.txt = "abcdef..."):
+   - Output sequence something like:
+     ```
+     abcde
+     de
+     ```
+     (kyunki reset ke baad d,e dobara read hue).
+
+6. Best Practice:
+   - Always close streams in `finally` block or use try-with-resources.
+   - BufferedInputStream ko prefer karo jab large files read karni ho (performance boost).
+   - Agar mark-reset ka use karna hai to `markSupported()` check kar lena.
+
+✔ FileInputStream → direct disk read, slow.
+✔ BufferedInputStream → buffer memory use karta hai, fast.
+✔ mark(), reset() → pointer ko manage karne ke liye.
+✔ markSupported() → feature available hai ya nahi check karne ke liye.
+*/

Section23JavaIOStreams/src/MyJAVA/BufferTest.txt

@@ -1 +1 @@
-Leadn Advance JAVA Programming.
+Learn Advance JAVA Programming.