What are Streams in Java?

Handling input and output (I/O) is an essential part of Java programming. Whether you're reading user input, writing data to files, or processing network connections, Java provides a powerful I/O system using Streams.

In this blog, we’ll explore:

• What Streams are
• Why we need them
• How they work
• Types of Streams in Java
• Simple examples to understand their usage

1. What are Streams?#

A Stream in Java is a sequence of data that flows from a source to a destination. Think of it like a pipeline that carries bytes of data from one place to another. Streams abstract the complexity of data transfer, making it easier to handle input and output operations.

Example Analogy:#

• A water pipe carries water from a tank (source) to a tap (destination).
• A Java Stream carries data from an input source (keyboard, file, network) to an output destination (console, file, network).

2. Why Do We Need Streams?#

Before Streams, handling I/O operations required dealing with low-level details like buffering, character encoding, and manual data transfers. Streams simplify this by:

• Providing a consistent way to handle different types of input and output.
• Automatically managing buffering and data conversion.
• Enabling efficient data transfer with minimal effort.

Without Streams (Using Arrays)#

char[] data = {'H', 'e', 'l', 'l', 'o'};
for (char c : data) {
    System.out.print(c);
}

• This approach works but lacks flexibility for reading files or network data.

With Streams (Using System.out)#

System.out.print("Hello");

• Java internally uses a PrintStream to send the output to the console.
• This is a stream-based approach, making it scalable and efficient.

3. Types of Streams in Java#

Java I/O Streams are categorized into two broad types:

A. Byte Streams (for handling binary data)#

• Deals with raw binary data (images, audio, videos, etc.).
• Uses InputStream and OutputStream classes.
• Reads/Writes one byte at a time.
• Example: FileInputStream, FileOutputStream.

B. Character Streams (for handling text data)#

• Designed for reading and writing character data.
• Uses Reader and Writer classes.
• Reads/Writes one character at a time.
• Example: FileReader, FileWriter.

4. Simple Example: Reading Input with Streams#

Let’s take a basic example using System.in, which is an InputStream for reading user input.

import java.io.IOException;

public class InputExample {
    public static void main(String[] args) throws IOException {
        System.out.println("Enter a character: ");
        int input = System.in.read(); // Reads a single byte
        System.out.println("You entered: " + (char) input);
    }
}

Output:#

Enter a character:
A
You entered: A

Explanation:#

• System.in.read() reads one byte from the keyboard.
• Since it reads an integer value (ASCII code), we cast it to a character.

5. Understanding Data Flow in Streams#

A stream pipeline in Java follows a simple flow:

Source → Stream → Destination

• Input Stream: Reads data from a source (file, keyboard, network).
• Processing: Optional transformations, like buffering or filtering.
• Output Stream: Writes data to a destination (console, file, network).

Example:

1. Keyboard (System.in) → InputStream → Program → OutputStream → Console (System.out)
2. File (FileInputStream) → InputStream → Program → OutputStream → Network (Socket OutputStream)

6. Key Differences: InputStream vs. OutputStream#

7. When to Use Streams in Java?#

• Use Byte Streams when dealing with binary files like images, videos, or serialized objects.
• Use Character Streams when working with text-based data (CSV, JSON, XML, etc.).
• Use Buffered Streams when performance matters (reduces I/O overhead by buffering data).
• Use Object Streams when working with serialization and deserialization of Java objects.

Conclusion#

In this blog, we introduced Java I/O Streams, their importance, and how they make handling input and output operations simpler. We also covered:

• The basic concept of streams and how they work.
• The difference between byte streams and character streams.
• A simple example of using System.in for reading input.
• When to use different types of streams.

In the next blog, we’ll dive deeper into InputStream and OutputStream classes, exploring how they work with real examples.