Java字节流文件复制

1、字节流

在 Java 中，文件的复制使用字节输入流和字节输出流实现，java.io 包有 InputStream 和 OutputStream 这两个顶层抽象类规范了读写文件所需的核心 API。

我们可以使用它们的子类 FileInputStream 和 FileOutputStream 来编写程序复制文件。

第一种方式：

使用 read() 和 write() 方法配合循环操作单字节的读取、写入

InputStream 的 read() 会尝试从文件读取一个字节，如果到了文件结尾则会返回-1

第二种方式：

使用 read(byte[]) 和 write(byte[], int, int) 方法配合字节缓冲、循环操作实现高效的读取、写入

InputStream 的 read(byte[]) 会尝试从文件读取 byte[] 长度个字节，该方法会把具体读取到的字节数返回，如果到了文件结尾则会返回 -1

OutputStream 的 write(byte[] buf, int offest, int len) 方法会把 buf 数组中从偏移量 offest 开始的 len 个字节写到输出流

2、单字节读写

 private static void copyFile(String src, String dst) throws IOException {

     // 用于计算程序运行时间
     long start = System.currentTimeMillis();

     // 定义输入流和输出流
     FileInputStream fis = null;
     FileOutputStream fos = null;
     try {

         // 实例化输入流和输出流
         fis = new FileInputStream(src);
         fos = new FileOutputStream(dst);

         int i = fis.read();

         // 循环从输入流读取字节，直到读取到-1即文件结尾
         while(i != -1) {
             fos.write(i); // 写出到输出流
             i = fis.read();
         }
     } catch (IOException e) {
         // 需要捕获IOException
         e.printStackTrace();
         throw e;
     } finally {
         // 在finally代码块关闭IO流
         try {
             if (fis != null)
                 fis.close();
             if (fos != null)
                 fos.close();
         } catch (IOException e) {}
     }

     // 计算程序运行时间
     long end = System.currentTimeMillis();
     System.out.println(end - start);
 }

3、定义缓冲高效读写

 private static void bufferedCopyFile(String src, String dst) throws IOException {

     // 用于计算程序运行时间
     long start = System.currentTimeMillis();

     // 定义输入流和输出流
     FileInputStream fis = null;
     FileOutputStream fos = null;
     try {

         // 实例化输入流和输出流
         fis = new FileInputStream(src);
         fos = new FileOutputStream(dst);

         // 定义一个字节缓冲数组
         byte[] buf = new byte[1024];
         int i = fis.read(buf);

         // 循环从输入流尝试读取buf长度的字节存放到buf中
         while(i != -1) {
             fos.write(buf, 0, i); // 把buf写到输出流
             i = fis.read(buf);
         }
     } catch (IOException e) {
         // 需要捕获IOException
         e.printStackTrace();
         throw e;
     } finally {
         // 在finally代码块关闭IO流
         try {
             if (fis != null)
                 fis.close();
             if (fos != null)
                 fos.close();
         } catch (IOException e) {}
     }
     // 计算程序运行时间
     long end = System.currentTimeMillis();
     System.out.println(end - start);
 }

4、程序运行

 public static void main(String[] args) {
     String src = "D:\\src.bmp";
     String dst = "D:\\tmp\\java\\dst.bmp";

     try {

         // 单字节读写
         copyFile(src, dst);

         // 定义缓冲高效读写
         bufferedCopyFile(src, dst);
     } catch (IOException e) {
         e.printStackTrace();
     }
 }

输出：

21092
162

可以看到定义了缓冲区的方法要比单字节地读写效率高很多