java文件复制-字节流

Posted 2023-02-19 小女子不才~~

欠下的迟早是要还的~~~，今天来还债了~

首先介绍两个字节流：InputStream和OutputStream，后边有复制的代码展示

InputStream和OutputStream是抽象类，是所有字节输入流和输出流的父类。

• InputStream(输入流):输入流是用来读入数据的。（读入）
• OutputStream(输出流):输出流是用来写出数据的。（写出）

(1)文件输入流——FileInputStream

FileInputStream 从文件系统中的某个文件中获得输入字节。

构造方法

（1） public FileInputStream(File file);

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

//创建一个读入流
FileInputStream in=new FileInputStream(new File("D:\\\\test\\\\test.txt"));

(2) public FileInputStream(String name);

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

FileInputStream in=new FileInputStream("D:\\\\test\\\\test.txt"); 

 两个构造方法虽然传参不同，但是使用效果是一样的，看源码会发现，FileInputStream(String name) 这个构造方法也是把传如的string地址转化成File文件对象,调用了FileInputStream(File file) 构造方法。

常用方法：

• close() 关闭流资源，释放资源
• read() 一次读取一个字节，返回int类型，每读取一个字节后指向位置会自动向后偏移一个字节，如果已读到末尾，会返回-1，即获取到-1就表示读取结束
• read(byte[] b) 一次读取多个字节，把字节存储到数组b中，返回中代表向b数组存储的字节个数，如返回值是-1，说明读取文件结束

(2)文件输出流——FileOutputStream

FileOutputStream文件输出流是用于将数据写入到文件中。

构造方法

（1）public FileOutputStream(File file);

创建一个向指定 File 对象表示的文件中写入数据的文件输出流

FileOutputStream out=new FileOutputStream(new File("d:\\\\test\\\\test11.txt"));

（2）public FileOutputStream(File file,boolean append)；

创建一个向指定 File 对象表示的文件中写入数据的文件输出流。如果第二个参数为 true，则将字节写入文件内容末尾处，也就是会拼接写入，而不是写入文件开始处。

FileOutputStream out=
new FileOutputStream(new File("d:\\\\test\\\\test11.txt"),true);

（3）public FileOutputStream(String name)

创建一个向具有指定名称的文件中写入数据的输出文件流;

FileOutputStream out=new FileOutputStream("d:\\\\test\\\\test11.txt");

（4）public FileOutputStream(String name,boolean append)

创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件内容末尾处，也就是会拼接写入，而不是写入文件开始处。

FileOutputStream out=new FileOutputStream("d:\\\\test\\\\test11.txt",true);

查看源码发现，public FileOutputStream(File file)和public FileOutputStream(String name) 两个构造方法使用同输入流是一样的，这里就不贴源码了，感兴趣的可自己去查看。

常用方法：

• close() 关闭流对象
• flush() 将缓冲区的内容刷新到文件中
• write() 一次写出一个字节
• write(byte[] b) 一次写出一个b数组的内容
• write(byte[] b,int offset, int len) 一次性从b数组指定位置offset开始，写出len个元素

@Test
public void copy()
    try 
        //创建一个读入流
        FileInputStream in=new FileInputStream("D:\\\\test\\\\test.txt");
        //创建一个输出流
        FileOutputStream out=new FileOutputStream("d:\\\\test\\\\test11.txt");
        //创建一个搬运工具
        byte data[]=new byte[20];
        //创建 长度
        int len=0;
        //in.read(data) 表示从该输入读取最1024*8字节的数据流到字节数组data[]中
        while((len=in.read(data))!=-1)
            out.write(data,0,len);//从指定字节数组data写入len字节从偏移off开始到此文件输出流，off=0,因为write里默认事append
        
        //关闭流
        in.close();  
        out.close();
     catch (Exception e) 
        e.printStackTrace();
    

级下的文件复制--使用高效缓冲流

高效缓冲流BufferedInputStream 和 BufferedOutputStream

缓冲区的意思

这两个流对象，本身不具备读写的能力，但能提高文件的读取写入效率

构造方法：

• BufferedInputStream(InputStream is)：增强输入流
• BufferedOutputStream(OutputStream os) :增强输出流

增强的原理：

BufferedInputStream：先准备一个缓冲区数组，每次调用read方法的时候，增强流会一次性的从文件流中读取8192个字节的内容，存到缓冲数组中，但是在调用read(byte[] date) 方法时，只会给你返回date.length长度的内容。下次调用read方法时，就不用再去进行io了，而是直接从缓冲数组取数据，由于数据在内存中获取数据是非常快的。当8192个字节全部读取完，再调用read()方法，他就会再次获取8192个字节，并返回一个，就减少了io的次数提高效率。

BufferedOutputStream：同样时先准备一个缓冲数组，存储输出的信息，当调用write方法写出字节时不是直接写到磁盘中，而是先放入缓冲数组中，当大小达到8192时，如果这个数据写满了，就一次性存储到磁盘中，再一次写出，就再准备一个数组，重复操作，写够8192个字节，才会操作一次磁盘，同样减少了io的次数，提高了效率。

代码实例：

@Test
public void copyButter()
    try 
        //创建一个读入流
        FileInputStream in=new FileInputStream(new File("D:\\\\test\\\\test2.txt"));
        //创建一个输出流
        FileOutputStream out=new FileOutputStream(new File("d:\\\\test\\\\test22.txt"));
        //定义读入，输出缓冲流 ,传
        BufferedInputStream bin=new BufferedInputStream(in);
        BufferedOutputStream bout=new BufferedOutputStream(out);
        //创建一个搬运工具
        byte data[]=new byte[20];
        //创建 长度
        int len=0;
        long start = System.currentTimeMillis();
        //从缓冲流中读取 表示从该输入读取最1024*8字节的数据流到字节数组data[]中
        while((len=bin.read(data))!=-1)
            bout.write(data,0,len);//从指定字节数组data写入len字节从偏移off开始到此文件输出流，off=0,因为write里默认事append
            //bout.flush(); //手动刷新缓冲区仅是把文件刷新到缓冲区，
            并不是把流关了，即调用完后还可以接着调用流。
        
        long end = System.currentTimeMillis();
        System.out.println("复制文件耗时："+(end-start));
        //关闭流的时候 ，后开的先关
        bin.close();
        bout.close();
        in.close();
        out.close();
     catch (Exception e) 
        e.printStackTrace();
    

输出流的close()和flush的区别

close()方法被调用前，会自动flush

close()关闭流对象，一旦关了，流对象就不能再用了

flush方法调用后，仅是把文件刷新到缓冲区，并不是把流关了，即调用完后还可以接着调用流

后记：天道好轮回，苍天饶过谁，该总结就总结吧，不能偷懒，欠下的迟早是要还的~~~