Java Input/Output Interview Questions

Java IO streams are primarily divided into byte streams and character streams, which are used to handle binary data and text data, respectively. Byte streams operate on a per-byte basis, making them suitable for processing binary content such as images and audio. Character streams operate on a per-character basis, making them ideal for handling text files. There are differences in implementation and performance between the two; byte streams are generally more efficient, but character streams require handling encoding issues.

II. Differences Between Byte Streams and Character Streams

Byte streams (such as InputStream and OutputStream) directly manipulate binary data, which is suitable for scenarios involving images, compressed files, etc. Character streams (such as BufferedReader and FileWriter) process text data through character encodings (such as UTF-8) and require additional handling for encoding conversion. For example, when using a character stream to read a text file, it is necessary to ensure that the file encoding matches the program's encoding; otherwise, garbled text will be generated.

III. Function and Implementation of Buffered Streams

Buffered streams (e.g., BufferedStream) improve IO efficiency by introducing a buffer (Buffer), thereby reducing the number of system calls. For instance, when BufferedReader reads a text file, it first loads the data into an in-memory buffer and then reads it block by block, significantly speeding up the reading process. However, buffered streams increase memory usage, so they should be selected reasonably based on actual needs.

IV. Core Methods for File Read/Write Operations

Java commonly uses methods from the File class for file operations, such as using FileInputStream to read binary data and FileWriter to write text. It is crucial to ensure the correctness of file paths to avoid resource exceptions caused by path errors. Additionally, using the try-with-resources statement to automatically close streams prevents resource leaks and is a high-frequency test point in Java interviews.

V. Serialization and Deserialization

Serialization (Serializable) converts an object into a byte stream, facilitating storage or transmission. Deserialization restores the byte stream back into an object. Java natively supports the Serializable interface, but note the following:

  1. The object must implement the Serializable interface, and version numbers must be consistent;
  2. Exceptions (such as InvalidClassException) must be handled during deserialization;
  3. For complex objects, use the ObjectOutputStream.writeObject() and ObjectInputStream.readObject() methods.

VI. IO in Network Communication

In network communication, Java uses Socket for the client side and ServerSocket for the server side to transmit data. Socket communication requires handling blocking issues, which can be optimized through asynchronous programming (such as NIO). For example, using BufferedInputStream and BufferedOutputStream reduces IO latency, but attention must be paid to exception handling when network interruptions occur.

VII. Strategies for Read/Write Performance Optimization

To improve IO performance, the following methods can be adopted:

  1. Use buffered streams (such as BufferedReader) to reduce system calls;
  2. Avoid frequent creation and destruction of stream objects;
  3. For large data files, prefer byte streams over character streams;
  4. Use asynchronous IO (such as NIO) for high-concurrency scenarios.
    However, note that excessive optimization may lead to increased code complexity, so a balance must be struck between performance and maintainability.

VIII. Common IO Exception Handling

Common exceptions in Java IO operations include:

  • IOException: A general exception that requires capturing all IO errors;
  • FileNotFoundException: Thrown when the file is not found;
  • EOFException: Triggered when the end of the file is reached during reading.
    Interviews often test how to automatically close streams using try-with-resources and how to capture and handle these exceptions.

IX. String Read/Write Operations

String read/write operations involve the InputStreamReader and OutputStreamWriter classes, which are used to convert characters into byte streams or vice versa. For example: 

try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("file.txt")))) {  
    String line = reader.readLine();  
}

Encoding issues must be noted; for instance, using UTF-8 encoding is recommended to prevent garbled text. Additionally, when reading or writing large files, it is recommended to use buffered streams to optimize performance.

X. Common Errors in IO Operations

Common errors include:

  1. FileNotFoundException caused by incorrect file paths;
  2. Resource leaks due to improper closure of streams;
  3. Garbled text resulting from inconsistent encodings;
  4. Program crashes due to unhandled IOException.
    Interviews often test how to avoid these errors, for example, through the use of try-with-resources and exception handling mechanisms.