写入文件的最快方法？

Question

我创建了一个采用File 和String 的方法。它用该字符串作为其内容的新文件替换文件。

这是我做的：

public static void Save(File file, String textToSave) {

    file.delete();
    try {
        BufferedWriter out = new BufferedWriter(new FileWriter(file));
        out.write(textToSave);
        out.close();
    } catch (IOException e) {
    }
}

但是它的速度非常缓慢。有时需要一分钟以上。

如何编写包含数万到一百万个字符的大文件？

Answer 1

确保分配足够大的缓冲区：

BufferedWriter out = new BufferedWriter(new FileWriter(file), 32768);

您在哪种操作系统上运行？这也可以产生很大的不同。但是，花 分钟 写出一个小于巨大大小的文件听起来像是一个系统问题。在 Linux 或其他 *ix 系统上，您可以使用 strace 之类的东西来查看 JVM 是否进行了大量不必要的系统调用。 （很久以前，Java I/O 相当愚蠢，如果你不小心的话，会产生疯狂的低级write() 系统调用，但是当我说“很久以前”时，我的意思是 1998 年左右.)

edit — 请注意，Java 程序以一种简单的方式编写一个简单的文件，但速度确实很慢，这种情况天生就很奇怪。你能知道在写入文件时 CPU 是否负载过重吗？不应该；这样的事情应该几乎没有CPU负载。

Answer 2

给你一个简单的测试

char[] chars = new char[100*1024*1024];
Arrays.fill(chars, 'A');
String text = new String(chars);
long start = System.nanoTime();
BufferedWriter bw = new BufferedWriter(new FileWriter("/tmp/a.txt"));
bw.write(text);
bw.close();
long time = System.nanoTime() - start;
System.out.println("Wrote " + chars.length*1000L/time+" MB/s.");

打印

Wrote 135 MB/s.

Answer 3

您可以研究 Java 的 NIO 功能。它可能支持你想做的事情。

Java NIO FileChannel versus FileOutputstream performance / usefulness

Answer 4

尝试使用内存映射文件：

FileChannel rwChannel = new RandomAccessFile("textfile.txt", "rw").getChannel();
ByteBuffer wrBuf = rwChannel.map(FileChannel.MapMode.READ_WRITE, 0, textToSave.length());

wrBuf.put(textToSave.getBytes());

rwChannel.close();

Answer 5

您好，我创建了两种创建大文件的方法，在 Windows 7、64 位、8 GB RAM 机器上运行程序，JDK 8 及以下是结果。
在这两种情况下，都会创建 180 MB 的文件，其中每行包含从 1 到 2000 万的数字（印度系统中为 2 千万）。

Java 程序内存逐渐增长到 600 MB

第一个输出

Approach = approach-1 (Using FileWriter)
Completed file writing in milli seconds = 4521 milli seconds.

第二次输出

Approach = approach-2 (Using FileChannel and ByteBuffer)
Completed file writing in milli seconds = 3590 milli seconds.

一个观察 - 我正在计算方法#2 中的位置（pos 变量），如果我将其注释掉，那么由于在位置处被覆盖，只有最后一个字符串可见，但时间减少到近 2000 毫秒。

附加代码。

import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.concurrent.TimeUnit;

public class TestLargeFile {

    public static void main(String[] args) {
        writeBigFile();
    }

    private static void writeBigFile() {
        System.out.println("--------writeBigFile-----------");
        long nanoTime = System.nanoTime();
        String fn = "big-file.txt";
        boolean approach1 = false;
        System.out.println("Approach = " + (approach1 ? "approach-1" : "approach-2"));
        int numLines = 20_000_000;
        try {
            if (approach1) {
                //Approach 1 -- for 2 crore lines takes 4.5 seconds with 180 mb file size
                approach1(fn, numLines);
            } else {
                //Approach 2 -- for 2 crore lines takes nearly 2 to 2.5 seconds with 180 mb file size
                approach2(fn, numLines);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("Completed file writing in milli seconds = " + TimeUnit.MILLISECONDS.convert((System.nanoTime() - nanoTime), TimeUnit.NANOSECONDS));
    }

    private static void approach2(String fn, int numLines) throws IOException {
        StringBuilder sb = new StringBuilder();
        FileChannel rwChannel = new RandomAccessFile(fn, "rw").getChannel();
        ByteBuffer wrBuf;

        int pos = 0;
        for (int i = 1; i <= numLines; i++) {
            sb.append(i).append(System.lineSeparator());
            if (i % 100000 == 0) {
                wrBuf = rwChannel.map(FileChannel.MapMode.READ_WRITE, pos, sb.length());
                pos += sb.length();
                wrBuf.put(sb.toString().getBytes());
                sb = new StringBuilder();
            }
        }
        if (sb.length() > 0) {
            wrBuf = rwChannel.map(FileChannel.MapMode.READ_WRITE, pos, sb.length());
            wrBuf.put(sb.toString().getBytes());
        }
        rwChannel.close();
    }

    private static void approach1(String fn, int numLines) throws IOException {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= numLines; i++) {
            sb.append(i).append(System.lineSeparator());
        }
        FileWriter fileWriter = new FileWriter(fn);
        fileWriter.write(sb.toString());
        fileWriter.flush();
        fileWriter.close();
    }
}

Answer 6

在 Java 中，BufferWriter 非常慢：直接使用本地方法，并尽可能少地调用它们（每次调用时尽可能多地为它们提供数据）。

    try{
        FileOutputStream file=new FileOutputStream(file);
        file.write(content);
        file.close();
    }catch(Throwable e){
        D.error(e);
    }//try

此外，删除文件可能需要一段时间（可能是先将其复制到回收站）。只需覆盖文件，就像上面的代码一样。