IO流框架

一、什么是流

• 概念：内存与存储设备之间的传输数据的通道
• 水借助管道传输；数据借助流传输

二、流的分类

• 按方向【重点】：

  • 输入流：将<存储设备>中的内容读入到<内存>中
  • 输出流：将<内存>中的内容写入到<存储设备>中

• 按单位：

  • 字节流：以字节为单位，可以读写所有数据
  • 字符流：以字符为单位，只能读写文本数据

• 按功能：

  • 节点流：具有实际传输数据的读写功能
  • 过滤流：在节点流的基础之上增强功能

2.1 字节流

• 字节流的父类（抽象类）：
  • InputStreamm：字节输入流
    • public int read() {}
    • public int read(byte[] b) {}
    • public int read(byte[] b, int off, int len) {}
  • OutputStream：字节输出流
    • public void write(int n) {}
    • public void write(byte[] b) {}
    • public void write(byte[] b, int off, int len) {}

2.1.1 文件字节流

• FileInputStream：
  • public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的结尾，则返回-1

做个测试，在d盘创建aaa.txt文件，输入字符；先看单个字节读取

package com.kongbai.flow;
import java.io.File;
import java.io.FileInputStream;

/**
 * @author kongbai
 * @version 1.0.0
 * @ClassName Demo01.java
 * @Description TODO
 * @createTime 2022年02月01日 16:14:00
 * 演示FileInputStream的使用
 * 文件字节输入流
 */
public class Demo01 {
   
    public static void main(String[] args) throws Exception{
   
        //1.创建FileInputStream,并指定文件路径
        File file;
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");

        //2.读取文件
        //int fir = fis.read(); //这个只能读取单个
        //System.out.println((char) fir);
        1.单个字节读取
        int data = 0;
        while ((data = fis.read()) != -1) {
   
            System.out.print((char) data + "\t"); //做个强制类型转换，否则输出结果均为数字
        }

        //3.关闭
        fis.close();
        System.out.println("读取完毕");
    }
}

再看看多字节读取

//2.一次读取多个字节
byte[] buf = new byte[3];
int count = 0;
while ((count = fis.read(buf)) != -1) {
   
    System.out.println(new String(buf, 0, count)); //从0开始取count个字节
}

• FileOutputStream：
  • public void write(byte[] b) //一次多个字节，将b数组中所有字节，写入输出流

package com.kongbai.flow;

import java.io.FileOutputStream;

/**
 * @author kongbai
 * @version 1.0.0
 * @ClassName Demo02.java
 * @Description TODO
 * @createTime 2022年02月17日 11:33:00
 * 文件字节输出流的使用
 * FileOutputStream
 */
public class Demo02 {
   
    public static void main(String[] args) throws Exception{
   
        //1.创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt");

        //2.写入文件
        fos.write(97);
        fos.write('b');
        fos.write('c');

        //3.关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

在d盘下就会出现bbb.txt文件，且内容为abc

像这样单字符添加效率太低，也可以直接添加一串字符

//单字符添加太慢，直接添加一串字符
String string = "hello world!";
fos.write(string.getBytes());

执行并打开文件，成功，但前面的abc被覆盖了

如需不覆盖，在创建文件字节输出流对象时，文件路径后添加true即可

FileOutputStream fos = new FileOutputStream("d:\\bbb.txt", true); //如果是true，将写入文件末尾

写个例子，使用文件字节流实现文件的复制，在硬盘中创建一个任意文件

package com.kongbai.flow;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author kongbai
 * @version 1.0.0
 * @ClassName Demo03.java
 * @Description TODO
 * @createTime 2022年02月17日 11:49:00
 * 使用文件字节流实现文件的复制
 */
public class Demo03 {
   
    public static void main(String[] args) throws Exception{
   
        //1.创建流
            //1.1文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\月球.jpg");
            //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:\\月球1.jpg");

        //2.复制（一边读，一边写）
        byte[] buf = new byte[2048];
        int count = 0;
        while ((count = fis.read(buf)) != -1) {
   
            fos.write(buf, 0, count);
        }

        //3.关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

执行完毕后就可以找到两个文件了

2.1.2 字节缓冲流

• 缓冲流：BufferedInputStream/BufferedOutputStream
  • 提高IO效率，减少访问磁盘的次数
  • 数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close

1.BufferedInputStream实例

package com.kongbai.flow;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;

/**
 * @author kongbai
 * @version 1.0.0
 * @ClassName Demo04.java
 * @Description TODO
 * @createTime 2022年02月18日 11:44:00
 * 使用字节缓冲流读取
 * BufferedInputStream
 */
public class Demo04 {
   
    public static void main(String[] args) throws Exception{
   
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\ccc.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);

        //2.读取
        int data = 0;
        while ((data = bis.read()) != -1) {
   
            System.out.print((char)data);
        }


        //3.关闭
        bis.close();
    }
}

也可以自己创建一个缓冲流，效果也是可以的

package com.kongbai.flow;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;

/**
 * @author kongbai
 * @version 1.0.0
 * @ClassName Demo04.java
 * @Description TODO
 * @createTime 2022年02月18日 11:44:00
 * 使用字节缓冲流读取
 * BufferedInputStream
 */
public class Demo04 {
   
    public static void main(String[] args) throws Exception{
   
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\ccc.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);

        //2.自行创建缓冲区
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = bis.read(buf)) != -1) {
   
            System.out.println(new String(buf, 0, count));
        }

        //3.关闭
        bis.close();
    }
}

2.BufferedOutputStream实例

package com.kongbai.flow;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;

/**
 * @author kongbai
 * @version 1.0.0
 * @ClassName Demo05.java
 * @Description TODO
 * @createTime 2022年02月18日 15:27:00
 * 使用字节缓冲流写入文件
 * BufferedOutput
 */
public class Demo05 {
   
    public static void main(String[] args) throws Exception{
   
        //1.创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //2.写入文件
        for (int i = 0; i < 10; i++) {
   
            //转移字符换行
            bos.write("hello world\r\n".getBytes()); //先写入8k缓冲区
            bos.flush(); //刷新到硬盘
        }<