title: 【学习之路】IO流学习
draft: true
tags:

Java IO原理

  • IO是Input/Output的缩写，用于处理设备之间的数据传输。如读写文件等。

  • 输入Input：读取外部数据到内存中

  • 输出Output：将程序内存数据输出到磁盘等储存设备

IO流的分类

  • 按照操作数据单位不同分为：字节流（8 bit），字符流（16 bit）
  • 按数据流的流向不同分为：输入流，输出流
  • 按流的角色的不同分为：节点流，处理流

IO流 - 图1

FileReader

read()方法的使用

  • 空参方法
  1. // 实列化File类对象，指明要操作的文件
  2. File file = new File("hello.txt");
  4. // 提供具体的流
  5. FileReader fr = new FileReader(file);
  7. // 数据的读入
  8. // read()：返回读入的一个字符，如果达到文件末尾，返回-1
  9. int data = fr.read();
  10. while(data != -1){
  11.     System.out.println((char)data);
  12.     data = fr.read();
  13. }
  15. // 流的关闭操作
  16. fr.close();
  1. // 读入操作语法上的修改
  2. int data;
  3. while ((data = fr.read()) != -1){
  4.     System.out.println((char) data);
  5. }
  1. FileReader fr = null;
  3. try{
  4.     // 实列化File对象
  5.     File file = new File("D:\\java-code\\JavaSETest\\src\\hello.txt");
  7.     // 实列化FileReader对象将File对象传入
  8.     fr = new FileReader(file);
  10.     // 数据的读入
  11.     // read()：返回读入的一个字符如果达到末尾，返回-1
  12.     int data;
  13.     while ((data = fr.read()) != -1){
  14.         System.out.println((char) data);
  15.     }
  16. }catch (IOException e){
  17.     e.printStackTrace();
  18. }finally {
  19.     // 流的关闭操作
  20.     try {
  21.         if (fr != null) {
  22.             fr.close();
  23.         }
  24.     } catch (IOException e) {
  25.         e.printStackTrace();
  26.     }
  27. }
  • char[]重载方法
  1. FileReader fr = null;
  3. try{
  4.     File file = new File("D:\\java-code\\JavaSETest\\src\\hello.txt");
  6.     fr = new FileReader(file);
  8.     // 读入操作
  9.     char[] cbuf = new char[5];
  10.     int len;
  11.     while ((len = fr.read(cbuf)) != -1){
  12.         // 错误的写法
  13.         for (int i = 0; i < cbuf.length; i++) {
  14.             System.out.print(cbuf[i]);
  15.         }
  16.     }
  17. }catch (Exception e){
  18.     e.printStackTrace();
  19. }finally{
  20.     // 关闭流的操作
  21.     try {
  22.         if (fr != null) {
  23.             fr.close();
  24.         }
  25.     } catch (IOException e) {
  26.         e.printStackTrace();
  27.     }
  28. }

这样写输出有问题，每次写入都是覆盖数组的操作，如果读到最后一次没有5个字符那么上次读取剩下来的字符就会保留

IO流 - 图2%E9%94%99%E8%AF%AF%E8%BE%93%E5%87%BA.png#alt=read%28%29%E9%94%99%E8%AF%AF%E8%BE%93%E5%87%BA)

正确的写法

  1. FileReader fr = null;
  3.         try{
  4.             File file = new File("D:\\java-code\\JavaSETest\\src\\hello.txt");
  6.             fr = new FileReader(file);
  8.             // 读入操作
  9.             char[] cbuf = new char[5];
  10.             int len;
  11.             while ((len = fr.read(cbuf)) != -1){
  12.                 // 错误的写法
  13. //                for (int i = 0; i < cbuf.length; i++) {
  14. //                    System.out.print(cbuf[i]);
  15. //                }
  16.                 // 正确的写法
  17.                 for (int i = 0; i < len; i++) {
  18.                     System.out.print(cbuf[i]);
  19.                 }
  20.             }
  21.         }catch (Exception e){
  22.             e.printStackTrace();
  23.         }finally{
  24.             // 关闭流的操作
  25.             try {
  26.                 if (fr != null) {
  27.                     fr.close();
  28.                 }
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }

IO流 - 图3%E6%AD%A3%E7%A1%AE%E8%BE%93%E5%87%BA.png#alt=read%28%29%E6%AD%A3%E7%A1%AE%E8%BE%93%E5%87%BA)

或者使用String的构造器来获取

  1.  // 读入操作
  2. char[] cbuf = new char[5];
  3. int len;
  4. while ((len = fr.read(cbuf)) != -1){
  5.     // 错误写法
  6.     // String str = new String(cbuf);
  7.     // System.out.print(str);
  9.     // 正确写法 获取数组，从第0位置到len的位置
  10.     String str = new String(cbuf, 0, len);
  11.     System.out.print(str);
  12. }

FileWriter

输出操作，对应的File可以不存在

如果不存在，那么就会自动创建此文件

如果存在：如果流使用的构造器是：FileWriter(file, true)：再原有文件追加内容 / FileWriter(File)：对原有文件的覆盖

writer()方法的使用

  1. FileWriter fw = null;
  3. try{
  4.     File file = new File("D:\\java-code\\JavaSETest\\src\\hello1.txt");
  5.     // 覆盖原有文件
  6.     fw = new FileWriter(file);
  7.     // 追加原有文件
  8.     // fw = new FileWriter(file, true);
  10.     fw.write("CodeXuan");
  11. }catch (Exception e){
  12.     e.printStackTrace();
  13. }finally{
  14.     try {
  15.         if (fw != null) {
  16.             fw.close();
  17.         }
  18.     } catch (IOException e) {
  19.         e.printStackTrace();
  20.     }
  21. }

File Input/Output Stream

如果使用字节流读取文件可能会出现乱码问题

  1. File file = new File("D:\\java-code\\JavaSETest\\src\\hello.txt");
  3. FileInputStream fis = null;
  5. try{
  6.     // 创建流
  7.     fis = new FileInputStream(file);
  9.     // 读取数据
  10.     byte[] buffer = new byte[5];
  11.     int len;
  12.     while ((len = fis.read(buffer)) != -1){
  13.         String str = new String(buffer, 0, len);
  14.         System.out.print(str);
  15.     }
  17. }catch (Exception e){
  18.     e.printStackTrace();
  19. }finally{
  20.     try {
  21.         if (fis != null) {
  22.             fis.close();
  23.         }
  24.     } catch (IOException e) {
  25.         e.printStackTrace();
  26.     }
  27. }

使用字节流复制文件，也可以使用字节流复制文本文件，但是最好不要再内存层面读取否则有可能出现乱码的情况

  1. long start = System.currentTimeMillis();
  3. File srcFile = new File("background.png");
  4. File destFile = new File("background-副本.png");
  6. FileInputStream fis = null;
  7. FileOutputStream fos = null;
  9. try{
  10.     fis = new FileInputStream(srcFile);
  11.     fos = new FileOutputStream(destFile);
  13.     // 复制操作
  14.     byte[] bytes = new byte[1024];
  15.     int len;
  16.     while ((len = fis.read(bytes)) != -1) {
  17.         fos.write(bytes, 0, len);
  18.     }
  19.     System.out.println("复制成功");
  20. }catch (Exception e){
  21.     e.printStackTrace();
  22. }finally{
  24.     try {
  25.         if (fis != null) {
  26.             fis.close();
  27.         }
  28.     } catch (IOException e) {
  29.         e.printStackTrace();
  30.     }
  32.     try {
  33.         if (fos != null) {
  34.             fos.close();
  35.         }
  36.     } catch (IOException e) {
  37.         e.printStackTrace();
  38.     }
  39. }
  41. long end = System.currentTimeMillis();
  42. System.out.println("复制花费的时间" + (end - start));

Buffered Input/Output Stream

  1. long start = System.currentTimeMillis();
  3. File srcFile = new File("background.png");
  4. File destFile = new File("background-副本.png");
  6. FileInputStream fis = null;
  7. FileOutputStream fos = null;
  9. BufferedInputStream bis = null;
  10. BufferedOutputStream bos = null;
  11. try{
  12.     // 创建节点流
  13.     fis = new FileInputStream(srcFile);
  14.     fos = new FileOutputStream(destFile);
  16.     // 创建缓冲流
  17.     bis = new BufferedInputStream(fis);
  18.     bos = new BufferedOutputStream(fos);
  20.     // 复制细节
  21.     byte[] bytes = new byte[1024];
  22.     int len;
  23.     while ((len = bis.read(bytes)) != -1){
  24.         bos.write(bytes, 0, len);
  25.     }
  26.     System.out.println("复制成功");
  27. }catch (Exception e){
  28.     e.printStackTrace();
  29. }finally{
  30.     // 资源关闭
  31.     // 要求：先关闭外层流，再关闭内层流
  32.     // 关闭外层流后，内层流会自动关闭，内层流的关闭可以省略
  33.     try {
  34.         if (bis != null) {
  35.             bis.close();
  36.         }
  37.     } catch (IOException e) {
  38.         e.printStackTrace();
  39.     }
  41.     try {
  42.         if (bos != null) {
  43.             bos.close();
  44.         }
  45.     } catch (IOException e) {
  46.         e.printStackTrace();
  47.     }
  48. }
  50. long end = System.currentTimeMillis();
  51. System.out.println("复制花费的时间" + (end - start));

BufferedReader/Writer

  • 方式一
  1. BufferedReader br = null;
  2. BufferedWriter bw = null;
  3. try {
  4.     br = new BufferedReader(new FileReader("hello.txt"));
  5.     bw = new BufferedWriter(new FileWriter("hello-副本.txt"));
  7.     char[] chars = new char[1024];
  8.     int len;
  9.     while ((len = br.read(chars)) != -1){
  10.         bw.write(chars, 0, len);
  11.     }
  12. } catch (IOException e) {
  13.     e.printStackTrace();
  14. } finally {
  15.     try {
  16.         if (br != null) {
  17.             br.close();
  18.         }
  19.     } catch (IOException e) {
  20.         e.printStackTrace();
  21.     }
  22.     try {
  23.         if (bw != null) {
  24.             bw.close();
  25.         }
  26.     } catch (IOException e) {
  27.         e.printStackTrace();
  28.     }
  29. }
  • 方式二
  1. BufferedReader br = null;
  2. BufferedWriter bw = null;
  3. try {
  4.     br = new BufferedReader(new FileReader("hello.txt"));
  5.     bw = new BufferedWriter(new FileWriter("hello-副本.txt"));
  7.    String data;
  8.    // readLine()一次读一行，使用这种方法不包含换行符
  9.    while ((data = br.readLine()) != null){
  10.        // 方式一：增加换行符
  11.        // bw.write(data + "\n");
  12.        // 方式二：增加换行符
  13.        bw.write(data);
  14.        bw.newLine();
  15.    }
  16. } catch (IOException e) {
  17.     e.printStackTrace();
  18. } finally {
  19.     try {
  20.         if (br != null) {
  21.             br.close();
  22.         }
  23.     } catch (IOException e) {
  24.         e.printStackTrace();
  25.     }
  26.     try {
  27.         if (bw != null) {
  28.             bw.close();
  29.         }
  30.     } catch (IOException e) {
  31.         e.printStackTrace();
  32.     }
  33. }

InputStreamReader

  • 将一个字节的输入流转换为字符的输入流
  1. InputStreamReader isr = null;
  2. try {
  3.     FileInputStream fis = new FileInputStream("hello.txt");
  5.     // 参数二指明字符集，具体使用的字符集，取决于文件保存时使用的字符集
  6.     isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
  8.     char[] chars = new char[20];
  9.     int len;
  10.     while ((len = isr.read(chars)) != -1){
  11.         String str = new String(chars, 0, len);
  12.         System.out.println(str);
  13.     }
  14. } catch (IOException e) {
  15.     e.printStackTrace();
  16. } finally {
  17.     try {
  18.         if (isr != null) {
  19.             isr.close();
  20.         }
  21.     } catch (IOException e) {
  22.         e.printStackTrace();
  23.     }
  24. }

OutputStreamWriter

  • 将一个字符的输出流转换为字节的输出流
  1. InputStreamReader isr = null;
  2. OutputStreamWriter osw = null;
  3. try {
  4.     // 获取文件
  5.     File file1 = new File("hello.txt");
  6.     File file2 = new File("hello-gbk.txt");
  8.     FileInputStream fis = new FileInputStream(file1);
  9.     FileOutputStream fos = new FileOutputStream(file2);
  11.     isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
  12.     osw = new OutputStreamWriter(fos, "GBK");
  14.     // 读写过程
  15.     char[] cbuf = new char[20];
  16.     int len;
  17.     while ((len = isr.read(cbuf)) != -1){
  18.         osw.write(cbuf, 0, len);
  19.     }
  20. } catch (IOException e) {
  21.     e.printStackTrace();
  22. } finally {
  23.     // 关闭流
  24.     try {
  25.         if (isr != null) {
  26.             isr.close();
  27.         }
  28.     } catch (IOException e) {
  29.         e.printStackTrace();
  30.     }
  31.     try {
  32.         if (osw != null) {
  33.             osw.close();
  34.         }
  35.     } catch (IOException e) {
  36.         e.printStackTrace();
  37.     }
  38. }