Java中IO流的使用

IO流操作讲解视频:https://www.bilibili.com/video/av48144058?p=585

首先要知道什么是IO流:将文件中的内容读到程序(内存),或者将程序中的数据写到文件(硬盘),这叫做IO流操作.也就是说对于文件的操作就叫做IO流操作
按照文件内容的不同分为字节流和字符流,当文件中存的是文字,也就是纯文本文件的时候,那么就是字符流,如果是一段视频,一个图片等等,那么就是字节流,又根据输入输出(或者读写,你要站在程序的角度讲输入输出和读写,也就是说将文件中的内容送到程序,那么就叫输入也叫读,将程序中的数据存到文件,那么就叫做输出,也叫做写)分为字节输入流(FileInputStream),字节输出流(FileOutputStream),字符输入流(FileReader),字符输出流(FileWriter)

所以进行IO操作的时候,你要先确定你的文件是字符文件(纯文本文件)还是字节文件(视频,图片),然后确认你要进行的是输入操作(读)还是输出操作(写),确定这两点之后,就可以定下来具体使用哪个操作(FileInputStream,FileOutputStream,FileReader,FileWriter)

节点流(就是我们上面讲的那四个),缓冲流就是加在节点流上的,以提高传输速率

字节流的操作(视频,图片等文件)

1）FileInputStream
FileInputStream：字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取诸如图像数据之类的原始字节流。

构造方法：
①// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定
FileInputStream(File file)
②// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径name指定

//使用方法示例1
        InputStream inputStream = new FileInputStream(new File("f://hello//test.txt"));
        int i = 0;
        //一次读取一个字节
        while ((i = inputStream.read()) != -1) {

            // System.out.print(i + " ");// 65 66 67 68
            //为什么会输出65 66 67 68？因为字符在底层存储的时候就是存储的数值。即字符对应的ASCII码。
            System.out.print((char) i + " ");// A B C D
        }
        //关闭IO流
        inputStream.close();
        //注:读取的文件不存在时会报错

//使用方法示例2
        InputStream inputStream2 = new FileInputStream("f://hello/test.txt");
        // 字节数组
        byte[] b = new byte[2];
        int i2 = 0;
        //  一次读取一个字节数组,一次读取一个字节数组，提高了操作效率
        while ((i2 = inputStream2.read(b)) != -1) {

            System.out.print(new String(b, 0, i2) + " ");// AB CD
        }
        //关闭IO流
        inputStream2.close();//IO流使用完毕一定要关闭。

2）FileOutputStream
FileOutputStream：字节文件输出流是用于将数据写入到File，从程序中写入到其他位置。

构造方法：
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file)
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file, boolean append)
// 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(String name)
// 创建一个向具有指定name的文件中写入数据的输出文件流
FileOutputStream(String name, boolean append)

//使用方法示例
OutputStream outputStream = new FileOutputStream(new File("test.txt"));
        // 写出数据
        outputStream.write("ABCD".getBytes());
        // 关闭IO流
        outputStream.close();

        // 内容追加写入
        OutputStream outputStream2 = new FileOutputStream("test.txt", true);
        // 输出换行符
        outputStream2.write("\r\n".getBytes());
        // 输出追加内容
        outputStream2.write("hello".getBytes());
        // 关闭IO流
        outputStream2.close();
        //注；输出的目的地文件不存在，则会自动创建，不指定盘符的话，默认创建在项目目录下;输出换行符时一定要写\r\n不能只写\n,因为不同文本编辑器对换行符的识别存在差异性。

3）BufferedInputStream
BufferedInputStream：字节缓冲输入流，提高了读取效率。

构造方法：
// 创建一个 BufferedInputStream并保存其参数，即输入流in，以便将来使用。
BufferedInputStream(InputStream in)
// 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流in以便将来使用
BufferedInputStream(InputStream in, int size)

//使用方法示例:
InputStream in = new FileInputStream("test.txt");
 // 字节缓存流
 BufferedInputStream bis = new BufferedInputStream(in);
byte[] bs = new byte[20];
int len = 0;
while ((len = bis.read(bs)) != -1) {
	System.out.print(new String(bs, 0, len));
    // ABCD
    // hello      
        }
        // 关闭流
bis.close();

4）BufferedOutputStream
BufferedOutputStream：字节缓冲输出流，提高了写出效率。

构造方法：
// 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out)
// 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size)

常用方法：
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此缓冲的输出流
void write(int b)
// 刷新此缓冲的输出流
void flush()

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true));
        // 输出换行符
        bos.write("\r\n".getBytes());
        // 输出内容
        bos.write("Hello Android".getBytes());
        // 刷新此缓冲的输出流
        bos.flush();
        // 关闭流
        bos.close();

字符流的操作(文本文件)

1）FileReader(使用方法和FileInputStream基本没有差别)
FileReader：用来读取字符文件的便捷类，使用默认字符编码。

//使用方法示例1
        FileReader fileReader= new FileReader(new File("f://hello//test.txt"));
        int i = 0;
        //一次读取一个字符
        while ((i = fileReader.read()) != -1) {
            System.out.print(i + " ");// A B C D
        }
        //关闭IO流
        inputStream.close();
        //注:读取的文件不存在时会报错

//使用方法示例2
        FileReader fileReader2 = new FileReader("f://hello/test.txt");
        // 字节数组
        char[] b = new char[2];
        int i2 = 0;
        //  一次读取一个字符数组,一次读取一个字符数组，提高了操作效率
        while ((i2 = inputStream2.read(b)) != -1) {

            System.out.print(new String(b, 0, i2) + " ");// AB CD
        }
        //关闭IO流
        inputStream2.close();//IO流使用完毕一定要关闭。

2）FileWriter(使用方法和FileOutputStream基本没有差别)
FileWriter：用来写入字符文件的便捷类，使用默认字符编码。

//使用方法示例
FileWriter fileWriter= new FileWriter(new File("test.txt"));
        // 写出数据
 fileWriter.write("ABCD");
        // 关闭IO流
 fileWriter.close();

 // 内容追加写入
FleWriter fileWriter2= new FileWriter("test.txt", true);
// 输出换行符
fileWriter2.write("\r\n");
 // 输出追加内容
fileWriter2.write("hello");
// 关闭IO流
fileWriter2.close();       
        //注；输出的目的地文件不存在，则会自动创建，不指定盘符的话，默认创建在项目目录下;输出换行符时一定要写\r\n不能只写\n,因为不同文本编辑器对换行符的识别存在差异性。

3）BufferedReader
BufferedReader：字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

构造方法：
// 创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in)
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz)
特有方法：
// 读取一个文本行
String readLine()

//使用方法示例
//生成字符缓冲流对象
        BufferedReader reader = new BufferedReader(new FileReader(new FileI("test.txt")));
        String str;
        //一次性读取一行
        while ((str = reader.readLine()) != null) {
            System.out.println(str);// 爱生活，爱Android
        }

        //关闭流
        reader.close();

4）BufferedWriter
BufferedWriter：字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

构造方法：
// 创建一个使用默认大小输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out)
// 创建一个使用给定大小输出缓冲区的新缓冲字符输出流
BufferedWriter(Writer out, int sz)
特有方法：
// 写入一个行分隔符
void newLine()

//使用方法示例
//生成字符缓冲流对象
        BufferedWriter writer= new BufferedWriter (new FileWriter(new File("test.txt")));
        String str;
        //一次性读取一行
        while ((str = writer.newLine()) != null) {
            System.out.println(str);// 爱生活，爱Android
        }

        //关闭流
        reader.close();

高效流效率比对

读取f盘下的一个视频文件到项目中：文件大小29.5 MB

读取方式一：

 FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
        FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
        int len;
        // 开始时间
        long begin = System.currentTimeMillis();
        // 一次读取一个字节
        while ((len = inputStream.read()) != -1) {
            outputStream.write(len);
        }
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin);// 213195
        //关闭流释放资源
        inputStream.close();
        outputStream.close();

读取方式二：

FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
        FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
        int len;
        byte[] bs = new byte[1024];
        // 开始时间
        long begin = System.currentTimeMillis();
        // 一次读取一个字节数组
        while ((len = inputStream.read(bs)) != -1) {
            outputStream.write(bs, 0, len);
        }
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin);// 281

        inputStream.close();
        outputStream.close();

读取方式三：

 FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4");
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4");
        BufferedOutputStream bos = new BufferedOutputStream(outputStream);
        int len;
        byte[] bs = new byte[1024];
        // 开始时间
        long begin = System.currentTimeMillis();
        while ((len = bis.read(bs)) != -1) {
            bos.write(bs, 0, len);
        }
        // 用时毫秒
        System.out.println(System.currentTimeMillis() - begin);// 78

        bis.close();
        bos.close();