Share a simple method to solve the exception of Java reading large files

Sharing of simple methods to solve Java large file reading exceptions

In the Java development process, sometimes we need to handle the reading operation of large files. However, because large files occupy a large amount of memory space, abnormal situations such as memory overflow often occur. This article describes a simple workaround, along with specific code examples.

When processing large files, we usually use segmented reading to divide the file into multiple smaller parts for processing to avoid loading the entire file into memory at once. Here is a simple example that demonstrates how to read a large file and output its contents:

import java.io.*;

public class LargeFileReader {

    public static void main(String[] args) {
        // 文件路径
        String filePath = "path/to/large/file.txt";
        // 每次读取的字节数
        int bufferSize = 1024;

        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            // 用于存储每次读取的数据
            char[] buffer = new char[bufferSize];
            // 用于存储每次读取的有效字符数
            int readChars;

            // 循环读取文件直到文件结束
            while ((readChars = br.read(buffer, 0, bufferSize)) != -1) {
                // 输出当前读取的数据
                System.out.print(new String(buffer, 0, readChars));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In the above example, we used BufferedReader to read a large file line by line. First, we define a buffer size (here 1024 bytes) to store the data for each read.

Then, we use FileReader to read the file into BufferedReader. Subsequently, we use the read method to read the specified number of characters into the buffer and save the valid number of characters in the readChars variable. If readChars is -1, it means that the end of the file has been read.

Finally, we output the currently read data through the System.out.print method. In this way, we can gradually read the contents of a large file without loading the entire file into memory at once, thereby avoiding the risk of memory overflow.

It should be noted that in actual applications, we may also need to perform other processing on the read data according to specific needs, such as writing to other files, performing complex data calculations, etc.

To sum up, by using segmented reading, we can solve the problem of Java large file reading exceptions, and the memory usage of one-time loading is also greatly reduced. I hope the simple method in this article can help everyone and can be used flexibly in actual development.

Reference materials:

• Oracle official documentation: https://docs.oracle.com/javase/8/docs/api/java/io/BufferedReader.html

The above is the detailed content of Share a simple method to solve the exception of Java reading large files. For more information, please follow other related articles on the PHP Chinese website!