In Java, Input and Output (I/O) operations are handled through the java.io and java.nio packages. These packages provide various classes to read and write data from different sources like files, console, and network streams.

Types of I/O in Java

1. Byte Stream (for binary data)
   • Uses InputStream and OutputStream classes.
   • Reads and writes data in bytes.
   • Examples: FileInputStream, FileOutputStream.
2. Character Stream (for text data)
   • Uses Reader and Writer classes.
   • Reads and writes data in characters (UTF-16).
   • Examples: FileReader, FileWriter.
3. Buffered Stream (for efficiency)
   • Uses BufferedReader and BufferedWriter for characters.
   • Uses BufferedInputStream and BufferedOutputStream for bytes.
4. Standard I/O (Console I/O)
   • Uses System.in, System.out, System.err.
   • Example: Scanner, BufferedReader.

1. Byte Stream Example (Reading and Writing a File)

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

public class ByteStreamExample {
    public static void main(String[] args) {
        try {
            // Writing to a file
            FileOutputStream fos = new FileOutputStream("example.txt");
            String text = "Hello, Java I/O!";
            fos.write(text.getBytes());
            fos.close();

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

2. Character Stream Example (Reading and Writing a File)

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharacterStreamExample {
    public static void main(String[] args) {
        try {
            // Writing to a file
            FileWriter writer = new FileWriter("textfile.txt");
            writer.write("This is a character stream example.");
            writer.close();

            // Reading from a file
            FileReader reader = new FileReader("textfile.txt");
            int i;
            while != -1) {
                System.out.print((char) i);
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. Buffered Stream Example

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.IOException;

public class BufferedStreamExample {
    public static void main(String[] args) {
        try {
            // Writing to a file using BufferedWriter
            BufferedWriter bw = new BufferedWriter(new FileWriter("buffered.txt"));
            bw.write("Buffered Writer Example in Java.");
            bw.newLine();
            bw.write("It improves performance!");
            bw.close();

            // Reading from a file using BufferedReader
            BufferedReader br = new BufferedReader(new FileReader("buffered.txt"));
            String line;
            while != null) {
                System.out.println(line);
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. Standard Input (Console I/O) Example

import java.util.Scanner;

public class ConsoleIOExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter your name: ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
        scanner.close();
    }
}

5. Using Files Class for I/O (Java NIO)

import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.List;

public class NIOExample {
    public static void main(String[] args) {
        String filePath = "niofile.txt";
        try {
            // Writing to a file
            Files.write(Paths.get(filePath), "Java NIO Example".getBytes());

            // Reading from a file
            List<String> lines = Files.readAllLines(Paths.get(filePath));
            lines.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Conclusion

• Use Byte Streams (InputStream, OutputStream) for handling binary files like images, audio, and videos.
• Use Character Streams (Reader, Writer) for handling text files.
• Use Buffered Streams for better performance.
• Use Scanner for reading input from the console.
• Use Java NIO (Files class) for modern file handling.

1. i = fis.read( [↩]
2. i = reader.read( [↩]
3. line = br.readLine( [↩]