The key to working with file and I/O streams in Java is to understand the basic concepts of streams and choose the right class library. 1. When reading text files, small files can be loaded quickly with Files.readAllLines(). It is recommended to use BufferedReader to read line by line to reduce memory usage. Pay attention to using try-with-resources to close streams and Paths.get() to build cross-platform paths. 2. It is recommended to use BufferedWriter to improve efficiency when writing files. Passing true when constructing FileWriter can achieve content addition. 3. You can use the Files.copy() and Files.move() methods to copy or move files, paying attention to the impact of non-atomic operations and cross-partition movement. 4. When processing binary data, you should use byte streams such as FileInputStream and FileOutputStream, and copying and other operations should be completed through buffer loop reading and writing. The buffer size can be adjusted according to requirements. Mastering the difference between character streams and byte streams, inputs and outputs will help to clearly respond to various I/O needs.

It is not actually mysterious to handle files and I/O streams in Java. As long as you understand the basic concepts of streams and the differences between input and output, most common file operations can be done more easily. Java provides a rich class library to support these operations, such as File , InputStream , OutputStream , Reader , Writer , etc.

Below are some common scenarios and practical suggestions to help you better understand file and I/O streaming operations in Java.

Read text file content

If you just want to quickly read the contents of a text file, using BufferedReader or Files.readAllLines() is the most straightforward way.

 List<String> lines = Files.readAllLines(Paths.get("example.txt"));

This method is suitable for situations where the document is not particularly large. If the file is large, it is recommended to read it line by line to avoid excessive memory usage:

• Read by line using BufferedReader
• Post-processing for each read one line, such as parsing or writing to other files
• Finally remember to close the stream (you can use try-with-resources)

Note: Path issues are prone to errors, especially under different operating systems. It is recommended to use Paths.get() to build cross-platform compatible paths.

Write data to file

When writing files, FileWriter and BufferedWriter are commonly used, which belong to character streams and are suitable for writing text content.

A simple example:

 try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    writer.write("This is what to write");
}

A few suggestions:

• Use try-with-resources to automatically close resources
• If you write frequently, use BufferedWriter to be more efficient
• If you want to append content instead of overwriting, pass in true parameter when constructing FileWriter

Binary data should use a byte stream, such as FileOutputStream , which will be mentioned later.

Copy or move files

The easiest way to copy files is to use Files.copy() method:

 Files.copy(sourcePath, targetPath);

If you want to replace the existing target file, you can add options:

 Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);

Moving files is similar, except that the method name is changed move() . What should be noted is:

• Move operations may not be atomic, depending on the file system
• If you cross disk partition, you actually copy first and then delete the original file
• File permissions may be lost, especially on Unix/Linux systems

Processing non-text data using byte stream

When you process non-text data such as pictures, audio, video, etc., you should use byte streams, such as FileInputStream and FileOutputStream .

A common way to copy binary files is as follows:

 try (InputStream in = new FileInputStream("source.bin");
     OutputStream out = new FileOutputStream("dest.bin")) {
    byte[] buffer = new byte[1024];
    int length;
    while ((length = in.read(buffer)) > 0) {
        out.write(buffer, 0, length);
    }
}

This mode is suitable for any binary file operation. Note that the buffer size can be adjusted according to actual conditions, such as using 8KB or 32KB to improve efficiency.

Basically that's it. Although there are many types of I/O classes in Java, as long as you distinguish between character streams and byte streams, inputs and outputs, and select the appropriate class based on specific needs, it is still very clear to operate.

The above is the detailed content of Working with Files and I/O Streams in Java. For more information, please follow other related articles on the PHP Chinese website!