java之IO流

1、java提供文件类+四大抽象类

包 java.io
文件/文件夹 File
字节流(二进制文件):inputstream outputstream
字符流:Reader Write

2、程序角度看输入输出

程序==========》目标文件
写操作/对程序而言是在输出
对程序而言写出去，就是输出

程序《==========目标文件
读操作/对程序而言是在输入
对程序 而言，有东西输入进来了，我读

3、转换流

字节流========》字符流

InputStreamReader
InputStream字节流Reader字符流，所以就是字节流转换到字符流
OutputStreamWriter
OutputStream字节流Write字符流，所以就是字节流转换到字符流

new BufferdReader(InputStreamReader(System.in))
new BufferWrite(new OutputStreamWrite(System.out))

3、对象流

序列化和反序列化
1.对象转换为二进制流
2.存入磁盘
3.从磁盘取出再转化为对象
ObjectOutputStream
ObjectInputeStream

###1、区别
字节流以字节为单位进行读写，可以处理所有类型的数据
字符流以字符为单位进行读写，只能用于处理文本数据
字符流通常使用缓冲区，可以提高读写性能；
而字节流则可以处理二进制数据，可以进行更底层的数据操作。

2、案例

1.字节流

字节流的基类，抽象类是表示字节流的所有类的超类。

InputStream字节输入流

常用方法：
    // 从输入流中读取数据的下一个字节
    abstract int read()
    // 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
    int read(byte[] b)
    // 将输入流中最多 len 个数据字节读入 byte 数组
    int read(byte[] b, int off, int len)
    // 跳过和丢弃此输入流中数据的 n个字节
    long skip(long n)
    // 关闭此输入流并释放与该流关联的所有系统资源
    void close()

OutputStream字节输出流

常用方法：
    // 将 b.length 个字节从指定的 byte 数组写入此输出流
    void write(byte[] b)
    // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
    void write(byte[] b, int off, int len)
    // 将指定的字节写入此输出流
    abstract void write(int b)
    // 关闭此输出流并释放与此流有关的所有系统资源
    void close()
    // 刷新此输出流并强制写出所有缓冲的输出字节
    void flush()

2.文件流

字节流的子类

FileInputStream

  // 读取f盘下该文件f://hell/test.txt
  //构造方法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();



// 读取f盘下该文件f://hell/test.txt
//构造方法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();

FileOutputStream

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();

3、字节缓冲流

字节流的子类

BufferedInputStream

 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();

BufferedOutputStream

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

4、字符流基类

读

 常用方法：
    // 读取单个字符
    int read()
    // 将字符读入数组
    int read(char[] cbuf)
    // 将字符读入数组的某一部分
    abstract int read(char[] cbuf, int off, int len)
    // 跳过字符
    long skip(long n)
    // 关闭该流并释放与之关联的所有资源
    abstract void close()

写

常用方法：
    // 写入字符数组
     void write(char[] cbuf)
    // 写入字符数组的某一部分
    abstract void write(char[] cbuf, int off, int len)
    // 写入单个字符
    void write(int c)
    // 写入字符串
    void write(String str)
    // 写入字符串的某一部分
    void write(String str, int off, int len)
    // 将指定字符添加到此 writer
    Writer append(char c)
    // 将指定字符序列添加到此 writer
    Writer append(CharSequence csq)
    // 将指定字符序列的子序列添加到此 writer.Appendable
    Writer append(CharSequence csq, int start, int end)
    // 关闭此流，但要先刷新它
    abstract void close()
    // 刷新该流的缓冲
    abstract void flush()

5、流转换/转换流

InputStreamReader和OutputStreamWriter是字符流的子类

1.字节流转换为字符流

InputStreamReader 是一个字符输入流，它将字节流转换为字符流
try (InputStream is = new FileInputStream("file.txt");
     Reader reader = new InputStreamReader(is, StandardCharsets.UTF_8)) {
    int c;
    while ((c = reader.read()) != -1) {
        System.out.print((char) c);
    }
} catch (IOException e) {
    e.printStackTrace();
}

2.字符流转换字节流

OutputStreamWriter 是一个字符输出流，它将字符流转换为字节流
try (OutputStream os = new FileOutputStream("file.txt");
     Writer writer = new OutputStreamWriter(os, StandardCharsets.UTF_8)) {
    writer.write("Hello, world!");
} catch (IOException e) {
    e.printStackTrace();
}

6、字符缓冲流

BufferedReade和BufferedWrite是字符流的子类

BufferedReade

try (Reader reader = new BufferedReader(new FileReader("file.txt"))) {
    int c;
    while ((c = reader.read()) != -1) {
        System.out.print((char) c);
    }
} catch (IOException e) {
    e.printStackTrace();
}

BufferedWrite

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

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

try (Writer writer = new BufferedWriter(new FileWriter("file.txt"))) {
    writer.write("Hello, world!");
} catch (IOException e) {
    e.printStackTrace();
}

通过使用缓冲区，可以减少读取和写入数据的次数，从而提高效率。
需要注意在使用完字符缓冲流后，要及时关闭对应的流对象，以释放资源

7、 便捷FileReader、FileWriter

 FileReader：InputStreamReader类的直接子类，用来读取字符文件的便捷类，使用默认字符编码。
 FileWriter：OutputStreamWriter类的直接子类，用来写入字符文件的便捷类，使用默认字符编码

8、高效流效率

        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();