Java输入输出流复制文件所用时间对比

1. 确定实验目标和环境

首先，我们要确定本次实验的目标，即比较不同输入输出流方式复制文件所用的时间。具体来说，我们要使用普通的字节流、带缓冲区的字节流、字符流和NIO四种方式，分别复制文件，并测量所用的时间，以比较不同方式的效率。

其次，我们需要准备实验的环境，包括需要复制的文件和用于测试时间的代码。

示例1：准备复制的文件

我们可以在测试时使用大小为100MB的文件，可以使用一些工具来生成指定大小的文件，如下所示：

# 生成大小为100MB的文件
dd if=/dev/urandom of=test.txt bs=1M count=100

示例2：编写用于测试时间的代码

我们可以编写一个Java程序，通过输入参数指定复制方式和需要复制的文件路径，然后通过计算开始和结束时间来测量复制所用的时间，最后输出结果。

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.Date;

public class TimeTest {
    public static void main(String[] args) {
        if (args.length != 2) {
            System.err.println("Usage: java TimeTest <copy method> <file path>");
            System.err.println("Copy method: 1=ByteStream, 2=BufferedByteStream, 3=CharStream, 4=NIO");
            System.exit(1);
        }

        int method = Integer.parseInt(args[0]);
        String filePath = args[1];

        File inFile = new File(filePath);
        String outFile = inFile.getParent() + File.separator + "out_" + method + "_" + inFile.getName();

        long startTime = new Date().getTime();

        switch (method) {
            case 1:
                byteStreamCopy(inFile, outFile);
                break;
            case 2:
                bufferedByteStreamCopy(inFile, outFile);
                break;
            case 3:
                charStreamCopy(inFile, outFile);
                break;
            case 4:
                nioCopy(inFile, outFile);
                break;
            default:
                System.err.println("Invalid copy method: " + method);
                System.exit(1);
        }

        long endTime = new Date().getTime();
        System.out.println("Time used: " + (endTime - startTime) + " ms");
    }

    private static void byteStreamCopy(File inFile, String outFile) {
        try (InputStream in = new FileInputStream(inFile);
             OutputStream out = new FileOutputStream(outFile)) {
            int len;
            byte[] buf = new byte[8192];
            while ((len = in.read(buf)) != -1) {
                out.write(buf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void bufferedByteStreamCopy(File inFile, String outFile) {
        try (InputStream in = new BufferedInputStream(new FileInputStream(inFile));
             OutputStream out = new BufferedOutputStream(new FileOutputStream(outFile))) {
            int len;
            byte[] buf = new byte[8192];
            while ((len = in.read(buf)) != -1) {
                out.write(buf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void charStreamCopy(File inFile, String outFile) {
        try (Reader reader = new FileReader(inFile);
             Writer writer = new FileWriter(outFile)) {
            int len;
            char[] cbuf = new char[8192];
            while ((len = reader.read(cbuf)) != -1) {
                writer.write(cbuf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void nioCopy(File inFile, String outFile) {
        try {
            Files.copy(Paths.get(inFile.getPath()), Paths.get(outFile), StandardCopyOption.REPLACE_EXISTING);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1. 实验过程

对于测试过程，我们需要使用命令行运行编写好的测试代码，并传入需要复制的文件路径和复制方式。根据不同方式运行代码，并记录所需时间。

示例1：使用普通字节流复制文件

$ java TimeTest 1 test.txt
Time used: 1866 ms

示例2：使用带缓冲区的字节流复制文件

$ java TimeTest 2 test.txt
Time used: 150 ms

1. 结果分析

根据上述两个示例，我们可以得出以下结论：

使用带缓冲区的字节流复制文件效率比普通字节流高很多，因为带缓冲区的字节流可以减少系统调用次数。

使用字符流复制文件效率要比带缓冲区的字节流低，因为字符流需要进行编码和解码操作。

使用NIO复制文件效率也很高，因为NIO使用了操作系统级别的IO操作。