Mastering Java IO : Part 4 - Developer Guide

Java IO (Input/Output) is a powerful toolset, allowing developers to read and write data from various sources like disks, networks, and memory. But with so many classes to choose from—InputStream, OutputStream, Reader, Writer, BufferedInputStream, BufferedReader, and more—it’s easy to get overwhelmed. How do you choose the right class for the job?

This guide aims to help developers make informed decisions when tackling Java I/O tasks, whether it’s reading from a network, writing to a disk, or managing large byte arrays in memory. We’ll walk through a structured approach using a decision tree based on your specific use case. By the end, you’ll have a clear path to the right class for your Java I/O task.

Why Java IO Classes Are Critical

Each I/O class in Java is designed with a specific purpose. Some are optimized for handling characters, others for raw bytes. Some are fast because they work with buffers, while others are more basic but may suit simpler use cases. Choosing the right tool for the job is crucial for efficiency, performance, and maintainability.

Before we dive into the decision tree, let’s break down the main categories.

Reading or Writing?
- Are you retrieving data (reading) or sending it (writing)?
Source or Destination: Disk, Network, or Memory?
- Will you be working with data stored on a disk, transmitted over a network, or kept in memory (e.g., arrays)?
Bytes or Characters?
- Will the data be in binary form (bytes) or textual form (characters)?
Buffered or Unbuffered?
- Will you use buffering for performance, or are you dealing with small amounts of data where direct access suffices?

Let’s take a closer look at these decisions through a practical lens.

Java IO Decision Tree: Finding the Right Class

To simplify the process, here’s a decision tree that will help you select the appropriate class based on your specific task:

1. Reading Data

1.1 Disk

1.1.1 Bytes

Buffered: Use BufferedInputStream
- This class wraps around a lower-level InputStream (like FileInputStream) to read bytes efficiently by reducing the number of reads from disk.

  try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("data.bin"))) {
      int data;
      while ((data = bis.read()) != -1) {
          System.out.print((char) data);
      }
  } catch (IOException e) {
      e.printStackTrace();
  }

Without Buffering: Use FileInputStream
- If buffering isn’t necessary (e.g., for small files), FileInputStream is sufficient for reading bytes directly.

  try (FileInputStream fis = new FileInputStream("data.bin")) {
      int data;
      while ((data = fis.read()) != -1) {
          System.out.print((char) data);
      }
  } catch (IOException e) {
      e.printStackTrace();
  }

1.1.2 Characters

Buffered: Use BufferedReader
- For reading text data, BufferedReader improves performance over FileReader by buffering chunks of characters.

  try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
      String line;
      while ((line = reader.readLine()) != null) {
          System.out.println(line);
      }
  } catch (IOException e) {
      e.printStackTrace();
  }

Without Buffering: Use FileReader
- If the data is small or buffering is unnecessary, FileReader will suffice for character-based reading.

  try (FileReader reader = new FileReader("data.txt")) {
      int data;
      while ((data = reader.read()) != -1) {
          System.out.print((char) data);
      }
  } catch (IOException e) {
      e.printStackTrace();
  }

1.2 Network

1.2.1 Bytes

Buffered: Use BufferedInputStream with Socket
- For efficient reading of byte streams over the network, buffer the input using BufferedInputStream combined with a Socket‘s input stream.

  try (Socket socket = new Socket("example.com", 80);
       BufferedInputStream bis = new BufferedInputStream(socket.getInputStream())) {
      int data;
      while ((data = bis.read()) != -1) {
          System.out.print((char) data);
      }
  } catch (IOException e) {
      e.printStackTrace();
  }

1.2.2 Characters

Buffered: Use BufferedReader with Socket
- Similarly, BufferedReader is ideal for reading text data over a network.

  try (Socket socket = new Socket("example.com", 80);
       BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
      String line;
      while ((line = reader.readLine()) != null) {
          System.out.println(line);
      }
  } catch (IOException e) {
      e.printStackTrace();
  }

1.3 Memory

1.3.1 Bytes

Buffered: Use ByteArrayInputStream (Buffering Optional)
- Reading bytes from memory is often done using ByteArrayInputStream, which wraps a byte array. While you don’t usually buffer in memory, you can chain it with BufferedInputStream if needed.

  byte[] byteArray = "Hello, Memory!".getBytes();
  try (BufferedInputStream bis = new BufferedInputStream(new ByteArrayInputStream(byteArray))) {
      int data;
      while ((data = bis.read()) != -1) {
          System.out.print((char) data);
      }
  } catch (IOException e) {
      e.printStackTrace();
  }

1.3.2 Characters

Buffered: Use CharArrayReader or StringReader
- For reading characters from memory, you can use CharArrayReader or StringReader, but since it’s in memory, buffering is typically unnecessary.

  String input = "Hello, Memory!";
  try (StringReader reader = new StringReader(input)) {
      int data;
      while ((data = reader.read()) != -1) {
          System.out.print((char) data);
      }
  } catch (IOException e) {
      e.printStackTrace();
  }

2. Writing Data

2.1 Disk

2.1.1 Bytes

Buffered: Use BufferedOutputStream
- For writing bytes to a file efficiently, wrap a FileOutputStream in a BufferedOutputStream to minimize disk access.

  try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.bin"))) {
      bos.write("Hello, Disk!".getBytes());
  } catch (IOException e) {
      e.printStackTrace();
  }

2.1.2 Characters

Buffered: Use BufferedWriter
- For text-based writing, BufferedWriter should be used for better performance when writing large amounts of text.

  try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
      writer.write("Hello, Disk!");
  } catch (IOException e) {
      e.printStackTrace();
  }

2.2 Network

2.2.1 Bytes

Buffered: Use BufferedOutputStream with Socket
- Writing bytes efficiently over a network can be achieved by combining a Socket‘s output stream with BufferedOutputStream.

  try (Socket socket = new Socket("example.com", 80);
       BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream())) {
      bos.write("GET / HTTP/1.1\n\n".getBytes());
  } catch (IOException e) {
      e.printStackTrace();
  }

2.3 Memory

2.3.1 Bytes

Buffered: Use ByteArrayOutputStream
- To write bytes into memory, the ByteArrayOutputStream class works well. Since the data is already in memory, buffering is usually not necessary, but BufferedOutputStream can be chained for consistency.

  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  try (BufferedOutputStream bos = new BufferedOutputStream(baos)) {
      bos.write("Hello, Memory!".getBytes());
  } catch (IOException e) {
      e.printStackTrace();
  }
  System.out.println(baos.toString());

While buffering is essential for improving performance in disk and network operations, it is less necessary for memory-based operations. However, in some cases where we require uniform handling of stream , we might need to add buffering for consistency. The decision tree bellow should give you a clearer picture of which class to use in your Java IO tasks.

By choosing the right combination of classes, whether you’re reading bytes from a disk, writing text to a network socket, or processing byte arrays in memory, you’ll optimize both your application’s performance and its maintainability.

To summarize in a beautiful way this article , I will let you check this mind map that gives you a decision tree, save it and give a thumbs up if you enjoy the article !

If you need to keep up-to-date with our latest articles, we strongly recommend you to subscribe to our newsletter, where we also share Java tips and tricks, advanced java topics and many useful resources to level up your java Knowledge !