Java基础学习之字节流（22）

1.1 IO流概述和分类

所有与IO操作相关的内容最后都要释放资源
IO流概述：

• IO：输入/输出
• 流：是一种抽象概念，是对数据传输的总称。流的本质就是数据传输
• IO流就是用来处理设备间数据传输问题的
  常见应用：文件辅助、文件上传、文件下载

IO流分类

• 按照数据流向
  输入流：读数据
  输出流：写数据
• 按照数据类型来分
  字节流
  字节输入流；字节输出流
  字符流
  字符输入流；字符输出流

如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流；分不清就使用字节流

1.2 字节流写数据

字节流抽象基类

• InputStream：这个抽象类是表示字节输入流的所有类的超类
• OutputStream：这个抽象类是表示字节输出流的所有类的超类
• 子类名特点：子类名称都是以其父类名作为子类名的后缀

FileOutputStream：文件输出流，用于将数据写入File
public FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

package java22;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

//public FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
public class demo1 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream f = new FileOutputStream("D:\\lyy\\f.txt");
        /*
        * 做了三件事情：
        *   调用系统功能创建文件
        *   创建字节输出流对象
        *   让字节输出流对象指向创建好的文件
        */
        //void write(int b):将指定的字节写入此文件输出流。
        f.write(99);
        f.write(57);//Ascall码57对应的数字9
        f.write(55);

        //最后都要释放资源
        //void close()：关闭此文件输出流并释放与此流相关联的任何系统资源。
        f.close();
    }
}

使用字节输出流写数据的步骤：

• 创建字节输出流对象（调用系统功能创建了文件、创建字节输出流对象、让字节输出流对象指向文件）
• 调用字节输出流写对象的方法
• 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）

1.2.1 字节流写数据的三种方式

• public void write(byte[] b) ： 将 b.length字节从指定的字节数组写入此文件输出流。
• public void write(int b) ：将指定的字节写入此文件输出流。
• public void write(byte[] b, int off, int len) ： 从位于偏移量 off的指定字节数组写入 len字节到该文件输出流。

package java22;


import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
//构造方法
//FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
//FileOutputStream(String name)：创建文件输出流以指定的名称写入文件。

//        - public void write(byte[] b) ： 将 b.length字节从指定的字节数组写入此文件输出流。
//        - public void write(int b)  ：将指定的字节写入此文件输出流。
//        - public void write(byte[] b, int off, int len) ： 从位于偏移量 off的指定字节数组写入 len字节到该文件输出流。


public class demo2 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流
        FileOutputStream fs = new FileOutputStream("D:\\lyy\\fs.txt");
        // new File(name),相对于下面语句
//        FileOutputStream fs = new FileOutputStream(new File("D:\\lyy\\fs.txt"));

        //FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
//        File file = new File("D:\\lyy\\fs.txt");
//        FileOutputStream fs2 = new FileOutputStream(file);
        //可以缩写为,fs和fs2的创建是等价的
//        FileOutputStream fs2 = new FileOutputStream(new File("D:\\lyy\\fs.txt"));

        //写数据的三种方式
        //public void write(int b)  ：将指定的字节写入此文件输出流。
        fs.write(97);
        fs.write(98);
        fs.write(99);
        fs.write(100);

        //public void write(byte[] b) ： 将 b.length字节从指定的字节数组写入此文件输出流
        byte[] by = {97,98,99,100};
        fs.write(by);
        //byte[] getBytes()  返回字符串对应的字节数组
        byte[] bys = "abcde".getBytes();
        fs.write(by);

        //public void write(byte[] b, int off, int len) ： 从位于偏移量 off的指定字节数组写入 len字节到该文件输出流。
        fs.write(by,0,by.length);
        fs.write(by,1,3);//写入指定起始和末尾的字节
        
        //释放资源
        fs.close();
    }

}

1.2.2 字节流写数据的两个小问题

字节流写数据如何实现换行：
写完数据后，加换行符
window:\r\n
linux:\n
mac:\r

字节流数据如何实现追加写入：
public FileOutputStream(String name, boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数是true ，则字节将写入文件的末尾而不是开头。

package java22;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
//字节流写数据实现换行
//    window:\r\n
//    linux:\r
//    mac:\r

//如何实现追加写入
//public FileOutputStream(String name, boolean append)
//        创建文件输出流以指定的名称写入文件。
//        如果第二个参数是true ，则字节将写入文件的末尾而不是开头。

public class demo3 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流
//        FileOutputStream fs = new FileOutputStream("D:\\lyy\\ja.txt");
        FileOutputStream fs = new FileOutputStream("D:\\lyy\\ja.txt",true);
        //写数据
        for(int i=0;i<10;i++){
            fs.write("hello".getBytes());
            //换行
            fs.write("\n".getBytes());
        }

        //释放资源
        fs.close();
    }
}

1.2.3 字节流写数据加异常处理

finally：在异常处理时提供finally块来执行所有清除操作。比如说IO流中的资源释放
特点:被finally控制的语句一定会执行，除非JVM退出

try{
可能出现异常的代码；
}catch(异常类名 变量名){
异常的处理代码；
}finally{
执行所有清除操作；
}

package java22;

import java.io.FileOutputStream;
import java.io.IOException;

public class demo4 {
    public static void main(String[] args) {
        //初始化变量
        FileOutputStream fs = null;
        try {
            //创建字节流输出
            fs = new FileOutputStream("D:\\lyy\\ja2.txt");
            fs.write("hello".getBytes());
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //判定fs是否为空，非空才进行释放操作，增强程序的健壮性
            if(fs != null) {
                try {
                    fs.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.3 字节流读数据（一次读一个字节数据）

FileInputStream：从文件系统中的文件获取输入字节。
构造方法：

• public FileInputStream(String name)：通过打开与实际文件的连接创建一个FileInputStream文件，该文件由文件系统中的路径名name命名。

使用字节输入流读数据的步骤：
创建字节输入流对象
调用字节输入流对象的读取方法
释放资源

package java22;

import java.io.FileInputStream;
import java.io.IOException;

public class demo5 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fs = new FileInputStream("D:\\lyy\\ja.txt");

        //调用字节输入流方法
        //public int read()：从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。
        //数据的下一个字节，如果达到文件的末尾，则返回值 -1 。
        //第一次读取数据
//        int by = fs.read();
//        System.out.println(by);
//        System.out.println((char)by);
//        //第二次读取数据
//        by = fs.read();
//        System.out.println(by);
//        System.out.println((char)by);
        //采用循环读取
/*        int by = fs.read();
        while(by != -1){
            System.out.print((char)by);
            by = fs.read();
        }*/
        //优化程序
        int by;
        while ((by=fs.read()) != -1){
            System.out.print((char)by);
        }


        //释放资源
        fs.close();
    }
}

案例：复制文本文件

package java22;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class demo6 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fs = new FileInputStream("E:\\窗里窗外.txt");

        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\lyy\\窗里窗外.txt");

        //读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
        int by;
        while ((by=fs.read()) != -1){
            fos.write(by);
        }

        //释放资源
        fs.close();
        fos.close();
    }
}

1.3.1 字节流读数据（一次读一个字节组的数据）

package java22;

import java.io.FileInputStream;
import java.io.IOException;

public class demo7 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\lyy\\窗里窗外.txt");

//        //第一次读取
//        byte[] by = new byte[5];
//        int len = fis.read(by);
//        System.out.println(len);
        System.out.println(new String(by));
//        System.out.println(new String(by,0,len));
//        //第二次读取
//        len = fis.read(by);
//        System.out.println(len);
        System.out.println(new String(by));
//        System.out.println(new String(by,0,len));
//        //第三次读取
//        len = fis.read(by);
//        System.out.println(len);
//        //String(byte[] bytes, int offset, int length)
//        System.out.println(new String(by,0,len));
        /*
        daiji\r\n
        fdafe\r\n
        第一次读取：daiji
        第二次读取：\r\nfda
        所以输出结果为：
        daiji

        fda
        * */

        //循环改进
        byte[] by = new byte[1024];//1024及其整数倍
        int len;
        while ((len=fis.read(by))!=-1){
            System.out.println(new String(by,0,len));
        }


        fis.close();
    }
}

案例：复制图片

package java22;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

//复制图片
public class demo8 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照\\证件照.jpg");
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照.jpg");

        byte[] by = new byte[1024];
        int len;
        while ((len=fis.read(by)) != -1){
            fos.write(by,0,len);
        }

        fos.close();
        fis.close();
    }
}

1.4 字节缓冲流

字节缓冲流：

• BufferedOutputStream该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。

• 当创建BufferedInputStream时，将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次有多个字节。

构造方法：

• BufferedOutputStream(OutputStream out) ：创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
• BufferedInputStream(InputStream in) ：创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
  为什么构造方法需要的是字节流，而不是具体的文件或者路径？
  字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作。

package java22;

import java.io.*;

public class demo9 {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流
//        FileOutputStream fos = new FileOutputStream("D:\\lyy\\窗里窗外.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //两个步骤合成一个步骤
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\lyy\\窗里窗外.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());

        //释放资源
        bos.close();

        //字节缓冲输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\lyy\\窗里窗外.txt"));
        //读数据,一次读取一个字节
        int by;
        while((by=bis.read())!=-1){
            System.out.print((char) by);
        }
        //一次读取一个字节数组的数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));
        }
        //释放资源
        bis.close();

    }
}

四种读写文件方式的时间测试

• 基本字节流一次读写一个字节
• 基本字节流一次读写一个字节数组
• 字符缓冲流一次读写一个字节
• 字节缓冲流一次读写一个字节数组

package java22;

import java.io.*;

public class demo10 {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制图片
//        mathod1();
//        method2();
//        method3();
        method4();

        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时："+(endTime-startTime)+"ms");
    }

    //基本字节流一次读写一个字节,耗时16371ms
    public static void method1() throws IOException{
        //创建字节输入对象
        FileInputStream fis = new FileInputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照\\证件照.jpg");

        //创建输出流对象
        FileOutputStream fos = new FileOutputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照.jpg");

        //一次读写一个字节
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        fis.close();
        fos.close();
    }

    //基本字节流一次读写一个字节数组,耗时24ms
    public static void method2() throws IOException{
        FileInputStream fis = new FileInputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照\\证件照.jpg");

        //创建输出流对象
        FileOutputStream fos = new FileOutputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照.jpg");

        //一次读写一个字节数组
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }
        fis.close();
        fos.close();
    }

    //字节缓冲流一次读写一个字节,共耗时96ms
    public static void method3() throws IOException{
        //创建字节输入对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照\\证件照.jpg"));

        //创建输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照.jpg"));

        //一次读写一个字节
        int by;
        while ((by=bis.read())!=-1){
            bos.write(by);
        }
        bis.close();
        bos.close();
    }

    //字节缓冲流一次读写一个字节数组，共耗时4ms
    public static void method4() throws IOException{
        //创建字节输入对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照\\证件照.jpg"));

        //创建输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\lyy\\Desktop\\个人资料\\证件照.jpg"));

        //一次读写一个字节数组
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            bos.write(len);
        }
        bis.close();
        bos.close();
    }
}

总结：尽量选择字节缓冲流一次读写一个字节数组