Character Stream Vs Byte Stream in Java

I/O Stream

A stream is a method to sequentially access a file. I/O Stream means an input source or output destination representing different types of sources e.g. disk files.The java.io package provides classes that allow you to convert between Unicode character streams and byte streams of non-Unicode text.

• Stream – A sequence of data.
• Input Stream: reads data from source.
• Output Stream: writes data to destination.

Character Stream

In Java, characters are stored using Unicode conventions (Refer this for details). Character stream automatically allows us to read/write data character by character. For example FileReader and FileWriter are character streams used to read from source and write to destination.

// Java Program illustrating that we can read a file in
// a human readable format using FileReader
import java.io.*; // Accessing FileReader, FileWriter, IOException
public class GfG
{
public static void main(String[] args) throws IOException
{
FileReader sourceStream = null;
try
{
sourceStream = new FileReader("test.txt");

// Reading sourcefile and writing content to
// target file character by character.
int temp;
while ((temp = sourceStream.read()) != -1)
System.out.println((char)temp);
}
finally
{
// Closing stream as no longer in use
if (sourceStream != null)
sourceStream.close();
}
}
}
Output :

Shows contents of file test.txt

Byte Stream

Byte streams process data byte by byte (8 bits). For example FileInputStream is used to read from source and FileOutputStream to write to the destination.

// Java Program illustrating the Byte Stream to copy
// contents of one file to another file.
import java.io.*;
public class BStream
{
public static void main(String[] args) throws IOException
{
FileInputStream sourceStream = null;
FileOutputStream targetStream = null;

try
{
sourceStream = new FileInputStream("sorcefile.txt");
targetStream = new FileOutputStream ("targetfile.txt");

// Reading source file and writing content to target
// file byte by byte
int temp;
while ((temp = sourceStream.read()) != -1)
targetStream.write((byte)temp);
}
finally
{
if (sourceStream != null)
sourceStream.close();
if (targetStream != null)
targetStream.close();
}
}
}

When to use Character Stream over Byte Stream?

• In Java, characters are stored using Unicode conventions. Character stream is useful when we want to process text files. These text files can be processed character by character. A character size is typically 16 bits.

When to use Byte Stream over Character Stream?

• Byte oriented reads byte by byte. A byte stream is suitable for processing raw data like binary files.
  Notes:
• Names of character streams typically end with Reader/Writer and names of byte streams end with InputStream/OutputStream
• The streams used in example codes are unbuffered streams and less efficient. We typically use them with buffered readers/writers for efficiency. We will soon be discussing use BufferedReader/BufferedWriter (for character stream) and BufferedInputStream/BufferedOutputStream (for byte stream) classes.
• It is always recommended to close the stream if it is no longer in use. This ensures that the streams won’t be affected if any error occurs.
• The above codes may not run in online compilers as files may not exist.