feat(io-byte-streams): implement file copy using FileInputStream and FileOutputStream

What
- Added `Test.java` demonstrating how to use Java byte streams (`FileInputStream`, `FileOutputStream`) to copy file contents.
- Reads raw bytes from `input.txt` and writes them into `output.txt` one byte at a time.
- Wrapped logic in try-catch-finally with proper resource management (manual closing of streams).
- Included inline revision notes summarizing:
  - Definition of byte streams.
  - Core classes (`FileInputStream`, `FileOutputStream`).
  - Code flow (`.read()`, `.write()` until EOF).
  - Real-world applications (copying files, network sockets, compressed formats).
  - Best practices (closing streams, try-with-resources).

Why
- Byte streams are the foundation of Java I/O for handling raw binary data.
- Many real-world applications (multimedia, networking, serialization) depend on efficient binary handling.
- This example provides a minimal yet complete demonstration of copying files at the byte level.
- Reinforces understanding of the `InputStream` / `OutputStream` hierarchy and low-level I/O mechanics.

Logic
1. **Setup**
   - Defined input (`input.txt`) and output (`output.txt`) file paths.
   - Initialized `FileInputStream` for reading and `FileOutputStream` for writing.

2. **Processing**
   - Loop reads bytes using `fis.read()`.
   - If return value != -1 (EOF marker), the byte is written to the output stream with `fos.write(byteData)`.

3. **Termination**
   - Loop ends at EOF (`-1`).
   - Streams are closed in `finally` to ensure resource cleanup regardless of exceptions.

4. **Error Handling**
   - `IOException` caught and stack trace printed.
   - Nested try-catch in `finally` ensures safe closing of both input and output streams.

Real-life applications
- **File Copy Utilities**: Low-level implementation for copying images, PDFs, executables.
- **Networking**: Transfer raw byte streams across sockets (e.g., HTTP, FTP).
- **Media Processing**: Reading/writing audio/video in raw format.
- **Compression**: Handling zipped or encrypted binary formats.

Notes
- `.read()` returns an `int` (0–255) or `-1` for EOF → important for correct loop termination.
- Streams must be closed to free system resources; modern Java prefers `try-with-resources`.
- Byte streams are efficient for binary data, while character streams (`Reader`, `Writer`) are better for text-based data.
- This example demonstrates sequential, single-byte I/O; buffered streams (`BufferedInputStream`, `BufferedOutputStream`) can improve performance for large files.

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

Author: Someshdiwan

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

@@ -0,0 +1,76 @@
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+public class Test {
+    public static void main(String[] args) {
+        // File paths (update as per your system)
+        String inputFile = "input.txt";
+        String outputFile = "output.txt";
+
+        FileInputStream fis = null;
+        FileOutputStream fos = null;
+
+        try {
+            // Create FileInputStream to read bytes from a file
+            fis = new FileInputStream(inputFile);
+
+            // Create FileOutputStream to write bytes to another file
+            fos = new FileOutputStream(outputFile);
+
+            int byteData;
+            // Read one byte at a time (-1 means end of a file)
+            while ((byteData = fis.read()) != -1) {
+                // Write the byte into an output file
+                fos.write(byteData);
+            }
+
+            System.out.println("File copied successfully using Byte Streams!");
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            try {
+                if (fis != null) fis.close();
+                if (fos != null) fos.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+
+/*
+Byte Streams in Java – Revision Notes
+
+1. Definition:
+   - Byte Streams in Java handle **raw binary data** (8-bit data).
+   - They use `InputStream` and `OutputStream` as base classes.
+   - Suitable for files like images, videos, audio, and text.
+
+2. Key Classes:
+   - FileInputStream → Reads raw bytes from a file.
+   - FileOutputStream → Writes raw bytes into a file.
+
+3. Code Flow:
+   - `new FileInputStream("input.txt")` → opens file for reading.
+   - `new FileOutputStream("output.txt")` → opens file for writing.
+   - `.read()` → reads 1 byte at a time (returns int in range 0–255).
+   - `.write(byte)` → writes 1 byte into file.
+   - Loop continues until `.read()` returns -1 (end of file).
+
+4. Real-World Use:
+   ✔ Copying binary files (images, PDFs, executables).
+   ✔ Sending/receiving data over network sockets.
+   ✔ Reading/writing compressed files.
+
+5. Important:
+   - Always close streams (`.close()`) to free system resources.
+   - Use `try-with-resources` in modern Java for automatic closing.
+
+Quick Recap:
+✔ Byte Streams = binary data handling.  
+✔ Use FileInputStream + FileOutputStream.  
+✔ `.read()` and `.write()` work byte-by-byte.  
+✔ Good for multimedia files and raw data transfer.  
+*/