Table of Contents

Overview of Java I/O Streams

What are I/O streams and why are they needed?

I/O (Input/Output) streams are used to read data from input sources (like files, network connections) and write data to output destinations (like files, network connections). They provide a standard way to handle different types of data sources and destinations, allowing Java programs to interact with the outside world.

• Reading Data: I/O streams enable a program to read data from various sources, such as files, user input, and network connections. For example, you might read a text file to display its contents or read data from a web service.
• Writing Data: They also allow a program to write data to different destinations, like saving user inputs to a file or sending data over the network. This is crucial for tasks like logging, data storage, and communication between systems.
• Standardization: Java's I/O streams provide a standard way to handle different types of input and output, making it easier to write flexible and reusable code. They abstract the complexity of dealing with different data sources and destinations, allowing developers to focus on core functionality.

I/O streams make it possible for Java programs to interact seamlessly with the external world, handling various types of data efficiently and consistently.

Byte streams and Character streams overview

• Byte Streams: Handle input and output of raw binary data. Classes like InputStream and OutputStream are used for byte streams.
• Character Streams: Handle input and output of characters. Classes like Reader and Writer are used for character streams.

High-level class structure and key classes

• InputStream: Provides methods to read bytes from a source. Subclasses of InputStream include FileInputStream (for reading from files) and BufferedInputStream (for efficient reading using a buffer).
• OutputStream: Provides methods to write bytes to a destination. Subclasses of OutputStream include FileOutputStream (for writing to files) and BufferedOutputStream (for efficient writing using a buffer).

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        // Writing bytes to a file
        try (FileOutputStream fos = new FileOutputStream("example.txt")) {
            String data = "Hello, Byte Streams!";
            fos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Reading bytes from a file
        try (FileInputStream fis = new FileInputStream("example.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Character Streams

• Definition: Character streams handle the input and output of characters (16-bit Unicode). They are designed to work with character data, which includes text files.
• Classes: The primary classes for character streams in Java are Reader and Writer, which are abstract classes that define methods for reading and writing characters.

Key Classes:

• Reader: Provides methods to read characters from a source. Subclasses of Reader include FileReader (for reading from files) and BufferedReader (for efficient reading using a buffer).