Java 通过字节流实现文件复制的四种方式

功能：

读取一个文件的字节流，在另一个文件夹将字节output到硬盘

文件越大，四种方式的比较效果越明显

输入：要复制的文件路径+文件名，该文件要复制的目标路径

输出：复制所耗时间（毫秒）

代码如下：

import java.io.*;

public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        String filepath = "D:\\JAVA\\FileTest\\test.jpg";//要复制的图片
        String copypath = "D:\\JAVA\\FileTest\\CopyFiles";//复制文件的目标路径

        String filename = new File(filepath).getName();//根据文件名截取后缀名：filename.substring(filename.lastIndexOf("."))
        System.out.println("---------本次复制的文件大小为："+new File(filepath).length()+"字节--------");

        copy1(filepath,copypath,filename.substring(filename.lastIndexOf(".")));
        copy2(filepath,copypath,filename.substring(filename.lastIndexOf(".")));
        copy3(filepath,copypath,filename.substring(filename.lastIndexOf(".")));
        copy4(filepath,copypath,filename.substring(filename.lastIndexOf(".")));
    }
    
    //方式1 每个字节循环遍历获取，效率低下
    public static void copy1(String filepath,String copypath,String fileType) throws IOException {
        //创建输入流 读取硬盘数据
        FileInputStream fis = new FileInputStream(filepath);

        //创建输出流 从内存写入硬盘
        FileOutputStream fos = new FileOutputStream(copypath+"\\copyBy单个字节"+fileType);

        long startTime = System.currentTimeMillis();
        int len;
        while ((len = fis.read()) != -1 ){
            fos.write(len);//遍历将每个字节写入新的文件
        }
        //释放资源，注意，释放资源必须要先释放写，再释放读
        fos.close();
        fis.close();
        System.out.println("按照每个字节完成复制，耗时"+(System.currentTimeMillis()-startTime)+"毫秒");
    }

    //方式2 使用缓冲数组byte[]遍历获取 效率高很多
    public static void copy2(String filepath,String copypath,String fileType) throws IOException {
        //创建输入流 读取硬盘数据
        FileInputStream fis = new FileInputStream(filepath);

        //创建输出流 从内存写入硬盘
        FileOutputStream fos = new FileOutputStream(copypath+"\\copyBy缓冲数组"+fileType);

        long startTime = System.currentTimeMillis();
        startTime = System.currentTimeMillis();
        int len;
        byte[] bytes = new byte[1024];//缓冲区大小为1024字节，也就是1K
        while ((len = fis.read(bytes)) != -1){
            fos.write(bytes,0,len);//如复制到文件大于1024字节，则每次写1024字节到缓冲数组 若小于1024字节，则直接全部写入缓冲数组
        }
        fos.close();
        fis.close();
        System.out.println("使用byte缓冲数组完成复制，耗时"+(System.currentTimeMillis()-startTime)+"毫秒");
    }

    //方式3 使用Buffered的缓冲流对每个字节循环遍历获取，效率比不使用Buffered要高许多
    public static void copy3(String filepath,String copypath,String fileType) throws IOException {
        //创建输入缓冲流 读取硬盘数据
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filepath));

        //创建输出缓冲流 从内存写入硬盘
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(copypath+"\\copyBy缓冲字节流"+fileType));

        long startTime = System.currentTimeMillis();
        int len;
        while ((len = bis.read()) != -1 ){
            bos.write(len);//遍历将每个字节写入新的文件
        }
        //释放资源，注意，释放资源必须要先释放写，再释放读
        bos.close();
        bis.close();
        System.out.println("缓冲字节流按照每个字节完成复制，耗时"+(System.currentTimeMillis()-startTime)+"毫秒");
    }

    //方式4 使用Buffered的缓冲流+缓冲数组byte[]遍历获取 效率最高
    public static void copy4(String filepath,String copypath,String fileType) throws IOException {
        //创建输入缓冲流 读取硬盘数据
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filepath));

        //创建输出缓冲流 从内存写入硬盘
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(copypath+"\\copyBy缓冲字节流和缓冲数组"+fileType));

        long startTime = System.currentTimeMillis();
        startTime = System.currentTimeMillis();
        int len;
        byte[] bytes = new byte[1024];//缓冲区大小为1024字节，也就是1K
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);//如复制到文件大于1024字节，则每次写1024字节到缓冲数组 若小于1024字节，则直接全部写入缓冲数组
        }
        bos.close();
        bis.close();
        System.out.println("缓冲字节流使用byte缓冲数组完成复制，耗时"+(System.currentTimeMillis()-startTime)+"毫秒");
    }
}

输出结果截图如下：

可以看出，就单个字节的复制而言，使用字节缓冲数组可以有效提高文件复制效率（比较第二行和第三行），而使用Buffer缓冲字节流也比基础的单个字节流复制要高许多（比较第二行和第四行）。但效率最高的是Buffer字节流缓冲和缓冲数组结合使用（第五行）。