IO流-文件复制

IO流

• 概述：IO流，输入输出流（Input Output）
• 流：一种抽象的概念，对数据传输的总称。（数据在设备之间的传输称为流）
• 常见的功能
  • 文件复制
  • 文件上传
  • 文件下载
• 学习流，我们要搞懂流的方向，这个是很重要的一个事情
  • 输入-读数据 （从硬盘到程序）
  • 输出-写数据 （从程序到硬盘）
• IO流分类
  • 按照数据流向
    • 输入流
    • 输出流
  • 按照数据类型
    • 字节流
    • 字符流
• 如何判断使用哪种流？
  • 通过自带记事本打开，能读懂内容，用字符流
  • 一般使用字节流

---

字节流

字节输入流

InputStream

• 概述：这个抽象类是字节输入流所有类的超类

FileInputStream

• 概述：文件输入流，InputStream 的子类

• 作用：将数据从硬盘读出展示到控制台上

• 常用方法

  方法	作用
  FileInputStream(String name)	通过打开与实际文件的连接来创建一个 FileInputStream,该文件由文件系统中的路径名 name 命名
  int read()	从该输入流读取一个字节数据，空值为（-1）
  int read(byte[] bys)	从该输入流读取一个字节数组，空值为（-1）

• 常用的两种读取格式

  // 一次读取一个字节数据
  int by;
  while((by = fis.read()) != -1){
      System.out.print((char)by);
  }
  

  // 一次读取一个字节数组
  byte[] bys = new byte[1024];
  int len;
  while((len = fis.read(bys)) != -1){
      System.out.print(new String(bytes, 0, len));
  }
  

• 代码演示

  • 首先，在 D 盘创建 一个 a.txt 文件，内容 abc123

  

  注意：fis.read(bys) 一次最大读取 1024 个数据，放入 bys 数组中，返回 当前读取的字符长度

字节输出流

OutputStream

• 概述：这个抽象类是表示字节输出流的所有类的超类

FileOutputStream

• 概述：文件字节输出流

• 作用：将数据写入到硬盘中

• 常用方法

  方法	作用
  FileOutputStream(String name)	创建文件输出流以指定的名称写入文件
  void write(int b)	将指定的字节写入此文件输出流(一次写一个字节数据)
  void write(byte[] b)	将b.length字节从指定的字节数组写入此文件输出流（一次写一个字节数组数据）
  void write(byte[] b , int off , int len)	将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流（一次写一个字节数组的部分数据）

• 代码演示

  public class Test {
      public static void main(String[] args) throws IOException {
          // 创建文件字节输出流对象
          FileOutputStream fos = new FileOutputStream("D:\\b.txt");
          // 一次写一字节
          fos.write(65);
  
          // 一次写一字节数组
          byte[] bys = {97,98,99,100};
          fos.write(bys);
  
          // 从指定位置写
          fos.write(bys,1,2);
  
          // 创建文件字节输入流对象
          FileInputStream fis = new FileInputStream("D:\\b.txt");
          // 读数据
          byte[] b = new byte[1024];
          int len;
          while((len = fis.read(b)) != -1){
              System.out.println(new String(b,0,len));
          }
      }
  }
  

  

  注意：FileOutputStream 我们直接调用写方法的时候，并未创建文件 b.txt,但是它自己生成了，所以默认当无此文件时，先创建再写入！

字节缓冲流

BufferedOutputStream

• 概述：字节缓冲输出流。该类实现缓冲输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

• 构造方法

  方法	作用
  BufferedOutputStream(OutputStream os)	根据字节输出流对象创建一个字节缓冲输出流对象

BufferedInputStream

• 概述：字节缓冲输入流。创建BufferedInputStream将创建一个内部缓冲区数组，当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填入，一次很多字节

  方法	作用
  BufferedInputStream(InputStream is)	根据字节输入流对象创建一个字节缓冲输入流对象

注意：字节缓冲流仅仅提供缓冲区，而真正的读写数据还是依靠基本的字节流对象进行操作

---

字符流

• 概述：字符流 = 字节流 + 编码表 ，不能直接写到文本中，需要刷新操作

字符输入流

Reader

• 概述：字符输入流的抽象类

FileReader

• 概述：用于读取字符文件的便捷类

  方法	作用
  FileReader(String fileName)	创建一个字符输入流对象

• 常用方法：和字节流的一样，只不过字节变成了字符

字符输出流

Writer

• 概述： 字符输出流的抽象类

FileWriter

• 概述：用于写入字符文件的便捷类

  方法	作用
  FileWriter(String fileName)	创建一个字符输出流对象
  void flush()	刷新资源

• 常用方法：和字节流的一样，只不过字节变成了字符

• 注意：这里写数据后，要调用 flush() 方法进行刷新才行，否则不会显示

字符缓冲流

BufferedReader

• 概述：字符缓冲输入流（读数据）可以指定缓冲区大小，默认大小已经足够大多数用途

• 常用方法和特有方法

  方法	作用
  BufferedReader(Reader in)	创建一个字符缓冲输入流对象
  String readLine()	读一行文字，结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

• 代码格式

  String line;
  while((line = br.readLine()) != null){
      System.out.println(line);
  }
  

BufferedWriter

• 概述：字符缓冲输出流（写数据）可以指定缓冲区大小，默认大小已经足够大多数用途

• 常用方法和特有方法

  方法	作用
  BufferedWriter(Writer out)	创建一个字符缓冲输出流对象
  void newLine()	写一行行分隔符，行分隔符字符串由系统属性定义

• 写数据步骤

  bw.writer(line);                 // 写数据
  bw.newLine();                    // 换行
  bw.flush();                      // 刷新资源
  

---

IO流总结

• 字节流可以复制任意文件数据，一般采用字节缓冲流一次读写一个字节数组的方式
• 字符流只能复制文本数据，一般采用字符缓冲流的特有功能

---

案例

字节流文件复制

public class Test {
    public static void main(String[] args) throws IOException {
        // 创建 文件字节输入流和输出流对象
        FileInputStream fis = new FileInputStream("D:\\a.txt");
        FileOutputStream fos = new FileOutputStream("D:\\b.txt");

        // 定义字节数组,用来存储读取到的字节
        byte[] bys = new byte[1024];
        // 存储读取到的字节长度
        int len;
        while((len = fis.read(bys)) != -1){
            // 将读取到的数据，写入新文件中
            fos.write(bys,0,len);
        }
        // 释放流
        fis.close();
        fos.close();
    }
}

字节缓冲流文件复制

public class Test {
    public static void main(String[] args) throws IOException {
        // 创建字节缓冲输入流和输出流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\b.txt"));
        // 定义字节数组
        byte[] bys = new byte[1024];
        int len;
        while((len = bis.read(bys)) != -1){
            bos.write(bys,0,len);
            // 记得刷新，要不不显示
            bos.flush();
        }
        // 释放流
        bis.close();
        bos.close();
    }
}

字符流文件复制

public class Test5 {
    public static void main(String[] args) throws IOException {
        // 创建文件字符输入流和输出流对象
        FileReader fr = new FileReader("D:\\a.txt");
        FileWriter fw = new FileWriter("D:\\b.txt");

        // 定义字符数组
        char[] chs = new char[1024];
        int len;
        while((len = fr.read(chs)) != -1){
            fw.write(chs,0,len);
            // 记得刷新
            fw.flush();
        }

        // 释放流     
        fr.close();
        fw.close();
    }
}

字符缓冲流文件复制

public class Test6 {
    public static void main(String[] args) throws IOException {
        // 创建 字符缓冲输入流和输出流对象
        BufferedReader br = new BufferedReader(new FileReader("D:\\a.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\b.txt"));

        // 定义存储 数据的 字符串
        String s;
        while((s = br.readLine()) != null){
            bw.write(s);
            // 换行
            bw.newLine();
            // 刷新
            bw.flush();
        }
        // 释放流
        br.close();
        bw.close();
    }
}