11.IO 流

1.IO 流引入

概述: 以应用程序为参照物,读取数据为输入流(Input),写数据为输出流(Output),大量输入输出数据简称 IO 流

原理:

2.IO 流的分类

读写的文件分类

  • 二进制文件:打开后是乱码,或者是 16 进制,无法生成文件的文件
  • 文本文件:打开文件内容可以直接阅读

IO流读取数据内容分类

  • 字符流:读取的内容最小单位是 char 类型
  • 字节流:读取的内容最小单位是 byte 类型

3.IO 流的访问方式分类

随机读写文件 :文件中存在一个游标,通过移动游标的方式,改变读写数据的位置
顺序读写文件:每次都从文件开始的位置开始读写

4.IO 字节流

输入输出字节流:InputStream、OutputStream

API:

  • int read():从流中读取一个字节,返回值为 int 类型
  • void wirte(int b):把一个字节写入到流中(把int 类型的低八位)
  • void close():关闭管道流

4.1.文件输出/入字节流

文件流: FileInputStream(文件输入流)、FileOutputStream(文件输出流)
特点: 文件流是节点流,直接可以操作磁盘的文件
节点流概念: 能够介质(文件、网络、控制台)直接相连的流
API:

  • FileInputStream(File file)
  • FileInputStream(String name)
  • FileOutputStream(String name)
  • FileOutputStream(String name, boolean append)
  • FileOutputStream(File file, boolean append)
  • FileOutputStream(File file)
java 复制代码
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 完成文件的拷贝
 */
public class FileStreamDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建一个文件输入流
        FileInputStream fis = new FileInputStream("test.txt");
        // 2.创建一个文件输出流
        FileOutputStream fos = new FileOutputStream("text.txt");
        // 3.创建一个数组
        byte[] data = new byte[1024];

        while (true) {
            // 4.读取数据
            int len = fis.read(data);
            // 7.判断读取的长度是否为 -1
            if (len == -1){
                System.out.println("文件拷贝成功");
                break;
            }
            // 5.写数据
            fos.write(data, 0, len);
        }
        // 6.关闭管道流
        fis.close();
        fos.close();

    }
}

4.2.ByteArray 字节流

Byte 字节流: ByteArrayInputStream(比特数组输入流)、ByteArrayOutputStream(比特数组输出流)
特点: 包含一个缓冲区,该缓冲区存储从流中读取的数据
API:

  • ByteArrayInputStream(byte[] buf)
  • ByteArrayInputStream(byte[] buf, int offset, int length)
java 复制代码
import java.io.*;

/**
 * 文件拷贝
 */
public class ByteArrayStreamDemo {
    public static void main(String[] args) throws IOException {
        // 1.创建一个文件管道流
        FileInputStream fis = new FileInputStream("E:\\software\\developSoftware\\Java\\JavaSE\\basic\\src\\test.txt");
        // 2.创建另一个文件输出流
        FileOutputStream fos = new FileOutputStream("E:\\software\\developSoftware\\Java\\JavaSE\\basic\\src\\123.txt");
        // 3.创建数组管道流
        ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
        // 5.定义数组
        byte[] data = new byte[1024];
        while (true) {
            // 4.读取数据
            int len = fis.read(data);
            // 7.跳出
            if (len == -1) break;
            // 6.写数据
            bos.write(data, 0, len);
        }
        bos.writeTo(fos);
        // 8.关闭管道
        fis.close();
        fos.close();
        bos.close();
    }
}

4.3.Data 字节流

Data 字节流: DataInputStream(数据输入流)、DataOutputStream(数据输出流)
**特点:**读取数据就是 Java 的数据类型,属于处理流

java 复制代码
import java.io.*;

public class DateStreamDemo {
    public static void main(String[] args) throws IOException {
        //1.创建输入管道流
        DataInputStream dis = new DataInputStream(new FileInputStream("test.txt"));
        //2.创建一个输出管道流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("text.txt"));
        //3.边读边写
        byte[] data = new byte[1024];
        while (true){
            int len = dis.read(data);
            if (len == -1) break;
            dos.write(data, 0 ,len);
        }
        //4.关闭管道
        dis.close();
        dos.close();
    }
}

4.4.缓冲字节流

缓冲字节流: BufferedInputStream(缓冲输入字节流)、BufferedOutputStream(缓冲输出字节流)
特点:

  • 处理了,一边和程序连接,一边和修饰流或者节点流连接。不能直接面对外部介质(文件、网络)
  • 缓冲流中的缓冲区为了提高读取或写入的效率,将读取或写入的文字暂时存储在缓冲区,当缓冲区满了之后,一起将数据读出或写入,减少读写的次数

API:

  • BufferedInputStream(InputStream is)
  • BufferedOutputStream(InputStream is)
  • int read(byte[] b):将读取文件内容放置在 byte[] 数组中,然后返回读取的字节数。int:读取的字节数。如果读到末尾,返回 -1
java 复制代码
import java.io.*;

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        //1.创建一个输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.txt"));
        //2.创建一个输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("text.java"));
        //3.边读边写
        byte[] data = new byte[1024];
        while (true){
            int len = bis.read();
            if (len == -1) break;
            bos.write(data, 0, len);
            bos.flush(); //当缓冲区满了就会自动刷出
        }
        //4.关闭流
        bis.close();
        bos.close();
    }
}

5.IO 字符流

5.1.输入输出字符流

输入输出字符流: Reader(输入字符流)、Writer(输出字符流)
特点:

  • 读写的内容是字符
  • 是抽象类
  • 是字符流的根类
  • 读取的文件是文本文件

PAI:

  • int read():读取文本文件内容
  • void write(int ):写入文件
  • void close():关闭管道

5.2.文件输入输出字符流

FileReader(文件输入字符流)、FileWriter(文件输出字符流)
特点: 读数据方式是字符、属于节点流
API:

  • FileReader(String fileName):根据路径加载文件,并且建立和程序的输入管道
  • FileWriter(String fileName):根据路径加载文件,并且建立和程序的输出管道
  • int reader(char[] c)
  • void write(char[] c);
  • void flush();
  • void close();
java 复制代码
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //获取文件路径
        String path = FileReaderDemo.class.getResource("").getPath();
        //1.创建文件输入字符流
        FileReader reader = new FileReader(path + "test.txt");
        //2.输出字符流
        FileWriter writer = new FileWriter(path +"text.txt");
        while (true){
            //3.读取文件内容
            int buf = reader.read();
            if (buf == -1) break;
            //将字符写入文件
            writer.write(buf);
            //情况缓冲区
            writer.flush();
        }
        //关闭管道流
        reader.close();
        writer.close();
    }
}