IO流-文件复制

news2024/9/21 22:48:56

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) 根据字节输出流对象创建一个字节缓冲输出流对象

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

BufferedInputStream

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

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

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

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

字符流

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

字符输入流

Reader

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

FileReader

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

方法作用
FileReader(String fileName) 创建一个字符输入流对象
常用方法：和字节流的一样，只不过字节变成了字符

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

字符输出流

Writer

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

FileWriter

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

方法作用
FileWriter(String fileName) 创建一个字符输出流对象
void flush() 刷新资源
常用方法：和字节流的一样，只不过字节变成了字符
注意：这里写数据后，要调用 flush() 方法进行刷新才行，否则不会显示

方法	作用
FileWriter(String fileName)	创建一个字符输出流对象
void 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() 写一行行分隔符，行分隔符字符串由系统属性定义

方法	作用
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();
    }
}