The most common way to read and write files in Java is to use the java.io package. The specific methods include: 1. Use FileReader and FileWriter to perform character-level reading and writing text files, which is suitable for processing human-readable text content; 2. Use BufferedReader and BufferedWriter to provide a buffering mechanism to improve the efficiency of reading and writing text by line, which is suitable for log analysis and configuration file parsing; 3. Use FileInputStream and FileOutputStream to process binary files, which is suitable for copying pictures, network transmission and other scenarios. These classes provide flexible choices based on the data type and operation method. It is recommended to combine try-with-resources to automatically manage resources and pay attention to exception handling and coding issues.

The most basic and most commonly used way to read and write files in Java is to use the Java I/O package ( java.io ). It provides a series of classes to handle input and output operations, and although there are more modern ways such as NIO ( java.nio ), java.io is still a standard practice that is still used in many projects. The following are several common methods and usage scenarios.

Use FileReader and FileWriter to read and write text files

These two classes are suitable for handling character streams, that is, plain text files. They read or write content by character, suitable for human-readable text such as English and Chinese.

Example of reading file:

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

Example of writing to a file:

 try (FileWriter writer = new FileWriter("output.txt")) {
    writer.write("This is what to write");
} catch (IOException e) {
    e.printStackTrace();
}

• It is recommended to use try-with-resources to automatically close resources.
• If you just simply read and write text, this method is simple and direct enough.
• Pay attention to encoding issues. If the file is not the default encoding (usually UTF-8), you may need to specify the encoding method (it is recommended to use InputStreamReader/OutputStreamWriter with FileInputStream/FileOutputStream).

Improve efficiency with BufferedReader and BufferedWriter

When you need to read or write text by line, it is recommended to use a buffered class, which can reduce the number of system calls and improve performance.

Example of reading by line:

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

Line by line writing example:

 try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    writer.write("first line");
    writer.newLine(); // newline writer.write("second line");
} catch (IOException e) {
    e.printStackTrace();
}

• The buffering mechanism allows as much data as possible for each read and write, suitable for large files.
• readLine() method is very convenient and is suitable for log analysis, configuration file analysis and other scenarios.
• If you need to frequently press rows, this combination is a good choice.

Handling binary files using FileInputStream and FileOutputStream

If you are reading and writing pictures, videos, audio, or other files in non-text formats, you should use a byte stream instead of a character stream.

Example of copying an image file:

 try (FileInputStream in = new FileInputStream("source.jpg");
     FileOutputStream out = new FileOutputStream("copy.jpg")) {
    byte[] buffer = new byte[1024];
    int bytesRead;
    while ((bytesRead = in.read(buffer)) != -1) {
        out.write(buffer, 0, bytesRead);
    }
} catch (IOException e) {
    e.printStackTrace();
}

• Byte streams operate data in units of byte[] and do not involve character encoding conversion.
• It is often used in scenarios such as copying files, network transmission, encryption and decryption.
• The buffer size can be adjusted according to actual conditions, such as 8KB or 64KB, which may be more efficient.

Basically that's it. Java I/O provides a variety of flexible classes to deal with different read and write needs. The key is to select the appropriate class based on the data type (text or binary) and operation method (character, line by line, batch). Although the code seems a bit cumbersome, after understanding the concept of streams, it is actually not complicated. It is just easy to ignore details, such as forgetting to close the stream or not handling exceptions.

The above is the detailed content of How to read and write files in Java I/O?. For more information, please follow other related articles on the PHP Chinese website!