Java IO Streams

So, what exactly are IO Streams, you ask? Well, think of them as channels that connect your Java program to various input and output sources, such as files, networks, and even other programs. They're like magic pipelines that allow your code to send and receive data seamlessly.

Imagine you're sending a letter to a friend. You write your message on a piece of paper, put it in an envelope, and send it off. In Java terms, the piece of paper is like your data, the envelope is the IO Stream, and the journey to your friend is the communication between your program and the outside world.

Now, let's break it down even further. Java IO Streams come in two flavors: input streams and output streams. Input streams are used to read data from a source, while output streams are used to write data to a destination.

Input Streams

FileInputStream

This class allows you to read bytes from a file in your file system. It's like having a magical book that you can open and read page by page.

import java.io.*;

public class FileInputStreamExample {
    public static void main(String[] args) {
        try {
            FileInputStream inputStream = new FileInputStream("example.txt");
            int data;
            while ((data = inputStream.read()) != -1) {
                System.out.print((char) data);
            }
            inputStream.close();
        } catch (IOException e) {
            System.out.println("An error occurred while reading the file: " + e.getMessage());
        }
    }
}

ByteArrayInputStream

This class reads bytes from an in-memory byte array. It's like having a jar of cookies that you can munch on whenever you're feeling hungry for data.

import java.io.*;

public class ByteArrayInputStreamExample {
    public static void main(String[] args) {
        byte[] data = { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100 };
        try {
            ByteArrayInputStream inputStream = new ByteArrayInputStream(data);
            int byteRead;
            while ((byteRead = inputStream.read()) != -1) {
                System.out.print((char) byteRead);
            }
            inputStream.close();
        } catch (IOException e) {
            System.out.println("An error occurred while reading the byte array: " + e.getMessage());
        }
    }
}

BufferedInputStream

This class adds buffering functionality to an input stream, improving performance by reducing the number of reads from the underlying stream. It's like having a sponge that soaks up data from a faucet before you drink it.

import java.io.*;

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        try {
            FileInputStream fileInputStream = new FileInputStream("example.txt");
            BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
            int data;
            while ((data = bufferedInputStream.read()) != -1) {
                System.out.print((char) data);
            }
            bufferedInputStream.close();
        } catch (IOException e) {
            System.out.println("An error occurred while reading the file: " + e.getMessage());
        }
    }
}

DataInputStream

This class allows you to read primitive Java data types from an input stream. It's like having a decoder ring that translates cryptic messages into meaningful information.

import java.io.*;

public class DataInputStreamExample {
    public static void main(String[] args) {
        try {
            FileInputStream fileInputStream = new FileInputStream("data.txt");
            DataInputStream dataInputStream = new DataInputStream(fileInputStream);
            int intValue = dataInputStream.readInt();
            double doubleValue = dataInputStream.readDouble();
            boolean booleanValue = dataInputStream.readBoolean();
            System.out.println("Int value: " + intValue);
            System.out.println("Double value: " + doubleValue);
            System.out.println("Boolean value: " + booleanValue);
            dataInputStream.close();
        } catch (IOException e) {
            System.out.println("An error occurred while reading the data: " + e.getMessage());
        }
    }
}

OutputStream

FileOutputStream

This class allows you to write bytes to a file in your file system. It's like having a magic pen that lets you write your thoughts and ideas onto the pages of a journal.

import java.io.*;

public class FileOutputStreamExample {
    public static void main(String[] args) {
        try {
            FileOutputStream outputStream = new FileOutputStream("output.txt");
            String data = "Hello, world!";
            outputStream.write(data.getBytes());
            outputStream.close();
            System.out.println("Data has been written to output.txt");
        } catch (IOException e) {
            System.out.println("An error occurred while writing to the file: " + e.getMessage());
        }
    }
}

ByteArrayOutputStream

This class writes bytes to an in-memory byte array. It's like having a magical spell that transforms your thoughts into invisible ink, which you can then reveal whenever you need it.

import java.io.*;

public class ByteArrayOutputStreamExample {
    public static void main(String[] args) {
        try {
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            String data = "Hello, world!";
            outputStream.write(data.getBytes());
            byte[] byteArray = outputStream.toByteArray();
            System.out.println(new String(byteArray));
            outputStream.close();
        } catch (IOException e) {
            System.out.println("An error occurred while writing to the byte array: " + e.getMessage());
        }
    }
}

BufferedOutputStream

This class adds buffering functionality to an output stream, improving performance by reducing the number of writes to the underlying stream. It's like having a sponge that soaks up ink before you write on the paper, ensuring smooth and efficient writing.

import java.io.*;

public class BufferedOutputStreamExample {
    public static void main(String[] args) {
        try {
            FileOutputStream fileOutputStream = new FileOutputStream("output.txt");
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
            String data = "Hello, world!";
            bufferedOutputStream.write(data.getBytes());
            bufferedOutputStream.close();
            System.out.println("Data has been written to output.txt");
        } catch (IOException e) {
            System.out.println("An error occurred while writing to the file: " + e.getMessage());
        }
    }
}

DataOutputStream

This class allows you to write primitive Java data types to an output stream. It's like having a translator that converts your thoughts into a language that others can understand.

import java.io.*;

public class DataOutputStreamExample {
    public static void main(String[] args) {
        try {
            FileOutputStream fileOutputStream = new FileOutputStream("data.txt");
            DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
            int intValue = 42;
            double doubleValue = 3.14;
            boolean booleanValue = true;
            dataOutputStream.writeInt(intValue);
            dataOutputStream.writeDouble(doubleValue);
            dataOutputStream.writeBoolean(booleanValue);
            dataOutputStream.close();
            System.out.println("Data has been written to data.txt");
        } catch (IOException e) {
            System.out.println("An error occurred while writing to the file: " + e.getMessage());
        }
    }
}