字符流通常是字节流的“包装器”

Question

While going through character stream information in java IO Stream, I found following lines hard to understand:

Character streams often “wrappers” for byte streams. the character stream uses the byte stream to perform the physical I/O, while the character stream handles translation between characters and bytes. FileReader, for example, uses FileInputStream, while FileWriter uses FileOutputStream.

would someone help me to understand... Thank you

Answer 1

At the lowest level a file consists of a byte sequence. The meaning of these bytes depends on the application which is responsible to read and write these bytes. The bytes can be interpreted as a JPEG image, a MP3 sound file or a text.

For a text interpretation you need a mapping between bytes and characters. These mappings are called character encodings. There are many different character encodings out there. For simple character encodings like Windows ANSI (Cp1252) or DOS encoding (Cp437) there is a one to one relationship between bytes and characters. So every character is encoded as exactly one byte.

But there are more complex encodings like UTF-8. The byte sequence for one character may consist of one byte or two or more bytes.

In Java the byte level is handled by the byte stream classes like FileInputStream and FileOutputStream . For character streams (text) there are the subclasses of Reader and Writer .

The two classes InputStreamReader and OutputStreamWriter are very important here, because these form the connection between character and byte streams.

An InputStreamReader is a Reader so you can read characters out of it. But it wraps an InputStream a byte stream. Internally it reads the bytes of the wrapped bytes stream and translate these bytes to characters according to a character encoding.

An OutputStreamWriter is a Writer . You write characters or strings into it. The OutputStreamWriter wraps an OutputStream . The characters are mapped to bytes with the encoding are written to the OutputStream .

If the character encoding isn't specified in the constructor then the platform's default encoding is used (usually Windows-ANSI on Windows and UTF-8 on Linux).

Example: To write the String Pelé to the file name.txt in UTF-8:

try(Writer writer = new OutputStreamWriter(new FileOutputStream("names.txt"), StandardCharsets.UTF_8)) {
  writer.write("Pelé");
} catch (IOException e) {
  e.printStackTrace();
}

Usually, you add additional Writers, eg for buffering or printing:

try(PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
    new FileOutputStream("names.txt"), StandardCharsets.UTF_8)))) {
  writer.println("Pelé");
} catch (IOException e) {
  e.printStackTrace();
}

To be complete, here is the corresponding reading example. Here we use Files.newBufferedReader() to create a FileInputStream wrapped by a BufferedReader :

Path namesFile = Paths.get("names.txt");
try(BufferedReader reader = Files.newBufferedReader(namesFile, StandardCharsets.UTF_8)) {
  reader.lines().forEach(System.out::println);
} catch (IOException e) {
  e.printStackTrace();
}