揭秘文件操作精髓：深入探索IO流的奥秘与力量！

1

认识 IO 流

2

万能钥匙字节流

//将一个制定范围的byte数组输出
void write(byte b[], int off, int len) 
close() //关闭资源
flush() // 在关闭资源的时候默认会调用刷新方法

@Test
  public void testOutput() {
    // 1、建立联系， File对象， 输出文件的地址
    // 如果文件不存在则可以创建文件并写入，
    // 但是如果加了文件夹，那么文件夹不存在则会产生FileNotFoundException，系统找不到指定的路径
    String path = "D:/txt/output.txt";
    File file = new File(path);
    // 2、选择流
    // 由于os要在finally中用到，放到try的外部，以提升os的变量作用范围
    OutputStream os = null;
    try {
      // 用FileOutputStream子类实例化父类OutputStream
      // 以追加的方式输出到文件，必须是true，否则就会覆盖原有的文件
      os = new FileOutputStream(file, true);
      // 3、操作
      String info = "演示字节输出流的使用\r\n用 FileOutputStream 类操作！\r\n";
      byte[] b = info.getBytes();// 字符串转字节数组
      os.write(b, 0, b.length);// 写出
      // 要养成这个习惯,为了避免缓存没有写出去，需要显示地flush一下
      os.flush();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
      System.out.println("文件不存在");
    } catch (IOException e) {
      e.printStackTrace();
      System.out.println("文件写出失败");
    } finally {
      try {
        // 4、释放资源
        if (os != null) {
          os.close();
        }
      } catch (Exception e2) {
        System.out.println("关闭文件输出流资源失败");
      }
    }
  }

@Test
  public void testInput() throws IOException {
    // 1、建立联系
    File file = new File("D:/output.txt");
    // 2、选择流
    InputStream is = new FileInputStream(file);
    // 3、读操作：即不断地读取
    byte[] b = new byte[1024]; // 缓存数组
    int len = 0; // 接收实际读取的大小
    while ((len = is.read(b)) != -1) {
      // 能读取到数据则输出，字节数组转成字符串
      String info = new String(b, 0, len);
      System.out.println(info);
    }
    is.close();
  }

演示字节输出流的使用
用 FileOutputStream 类操作！
演示字节输出流的使用
用 FileOutputStream 类操作！

@Test
  public void testCopy() throws IOException {
    // 1、使用File类与文件建立联系
    File srcFile = new File("D:/file/image/tomcat.png");
    File destFile = new File("D:/file/image/tomcat1.jpg");
    // 2、选择对应的输入流或者输出流
    InputStream is = new FileInputStream(srcFile);
    OutputStream os = new FileOutputStream(destFile);
      // 3、进行读或写操作
      byte[] b = new byte[1024];
      int len = 0;
      while ((len = is.read(b)) != -1) {
        // 判断每次读取的内容长度，如果不等于-1，表示文件没有读完
        // 选择带参数的write方法，就是为了避免byte缓存比实际内容多的时候，输出多余的空内容
        os.write(b, 0, len);
      }
    os.flush();
    // 4、关闭资源，先创建的后关闭
    os.close();
    is.close();
  }

3

纯文本操作字符流

int read(char cbuf[]) //读取char数组中的内容，返回读入的长度
close() //关闭资源

//将一个字符串输出
void write(String str)
//将一个字符数组输出
void write(char cbuf[], int off, int len)
close() //关闭资源
flush() // 在关闭资源的时候默认会调用刷新方法

@Test
  public void testWriter() throws IOException {
    // 1、使用File类与文件建立联系
    File file = new File("D:/file/txt/output_char.txt");
    // 2、选择对应的输入流或者输出流
    Writer writer = new FileWriter(file, true);
    String info = "演示字符输出流的使用\r\n用 FileWriter 类操作！\r\n";
    // 3、进行写操作
    writer.write(info); //将一个字符串组输出
    writer.flush();
    // 4、关闭资源
    writer.close();
  }

@Test
  public void testReader() throws IOException {
    // 1、使用File类与文件建立联系
    File file = new File("D:/file/txt/output_char.txt");
    // 2、选择对应的输入流或者输出流
    Reader reader = new FileReader(file);
    char[] cbuf = new char[1024];
    int len = 0;
    // 3、进行写操作
    while ((len = reader.read(cbuf)) != -1) {
      String info = new String(cbuf, 0, len); // 字符数组转成字符串
      System.out.println(info);
    }
    // 4、关闭资源
    reader.close();
  }

演示字符输出流的使用
用 FileWriter 类操作！
演示字符输出流的使用
用 FileWriter 类操作！

@Test
  public void testTxtCopy() throws IOException {
    // 1、使用File类与文件建立联系
    File srcFile = new File("D:/file/txt/output_char.txt");
    File destFile = new File("D:/file/txt/output_char1.txt");
    // 2、选择对应的输入流或者输出流
    Reader read = new FileReader(srcFile);
    Writer write = new FileWriter(destFile);
    // 3、进行读写操作
    char[] cbuf = new char[1024];
    int len = 0;
    while ((len = read.read(cbuf)) != -1) {
      write.write(cbuf, 0, len); //将一个字符数组输出
    }
    write.flush();
    // 4、关闭资源
    write.close();
    read.close();
  }

4

字节流与字符流的区别

/**
   * 把flush方法和close方法去掉，观察程序运行结果，用字符流输出内容到文件是空的
   */
  @Test
  public void testWriter1() throws IOException {
    // 1、使用File类与文件建立联系
    File file = new File("D:/file/txt/output_char_buffer.txt");
    // 2、选择对应的输入流或者输出流
    Writer writer = new FileWriter(file, true);
    String info = "把flush方法和close方法去掉，观察程序运行结果，输出的内容文件是空的！\r\n";
    // 3、进行写操作
    writer.write(info);
  }

/**
   * 把flush方法和close方法去掉，观察程序运行结果，用字节流可以输出内容到文件
   */
  @Test
  public void testOutput1() throws IOException {
    // 1、使用File类与文件建立联系
    File file = new File("D:/file/txt/output_char_output.txt");
    // 2、选择对应的输入流或者输出流
    OutputStream os = new FileOutputStream(file, true);
    // 3、进行写操作
    String info = "把flush方法和close方法去掉，观察程序运行结果，输出的内容文件是空的！\r\n";
    byte[] b = info.getBytes();// 字符串转字节数组
    os.write(b, 0, b.length);// 写出
  }

/**
   * 调用flush方法，不调用close方法，观察程序运行结果，用字符流输出内容到文件是可以的，说明字符输出流确实用到了缓冲区
   */
  @Test
  public void testWriter2() throws IOException {
    // 1、使用File类与文件建立联系
    File file = new File("D:/file/txt/output_char_writer.txt");
    // 2、选择对应的输入流或者输出流
    Writer writer = new FileWriter(file);
    String info = "调用flush方法，不调用close方法，观察程序运行结果，用字符流输出内容到文件是可以的，说明字符输出流确实用到了缓冲区！\r\n";
    // 3、进行写操作
    writer.write(info);
    // 4、强制刷出
    writer.flush();
  }

/**
   * 调用close方法，不调用flush方法，观察程序运行结果，用字符流输出内容到文件是可以的，说明字符输出流确实用到了缓冲区
   */
  @Test
  public void testWriter3() throws IOException {
    // 1、使用File类与文件建立联系
    File file = new File("D:/file/txt/output_char_writer.txt");
    // 2、选择对应的输入流或者输出流
    Writer writer = new FileWriter(file);
    String info = "调用close方法，不调用flush方法，观察程序运行结果，用字符流输出内容到文件是可以的，说明字符输出流确实用到了缓冲区！\r\n";
    // 3、进行写操作
    writer.write(info);
    // 4、关闭资源
    writer.close();
  }