小编点评

## Summary of the Stream Demo This document provides an overview of different ways to perform file operations using streams in Java. It's divided into several sections: **1. Introduction** - Explains the purpose of IO streams. - Introduces the concepts of files, input, and output streams. **2. Reading and Writing Files** - Shows how to create file input and output streams. - Reads data from the file and writes it to another file. - Provides a simple example of copying a file using `FileInputStream` and `FileOutputStream`. **3. Reading and Writing Data in Bytes** - Introduces `ByteArrayInputStream` and `ByteArrayOutputStream` for reading and writing byte-level data. - Provides an example of reading and writing a file in bytes. **4. Reading and Writing Data in Buffers** - Introduces `BufferedInputStream` and `BufferedOutputStream` for reading and writing data in chunks. - Shows how to use buffers to improve performance by reading or writing entire blocks of data. **5. Reading and Writing Text Files** - Demonstrates how to read and write text files using `FileReader` and `FileWriter`. - Provides an example of reading and writing a file line by line. **6. Conclusion** - Recap the different types of streams and their usage in file operations. - Provides two additional ways to read and write data: `FileReader` and `FileWriter`.

正文

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)

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)

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 的数据类型，属于处理流

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

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();

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();
    }
}