Java中的IO流可以分为节点流和处理流两种类型。节点流负责直接从源读取数据或将数据直接写入目标，而处理流则负责对数据进行处理后再读取或写入，处理流是建立在节点流的基础之上的，是一种包装节点流的类。

节点流

在Java IO中，节点流主要包括以下几种：

InputStream和OutputStream：InputStream和OutputStream是所有输入流和输出流的父类，它们定义了读和写的基本操作。InputStream提供了read()方法，可以读取一个字节或一组字节，而OutputStream提供了write()方法，可以写入一个字节或一组字节。
FileInputStream和FileOutputStream：FileInputStream和FileOutputStream是用于读写文件的流。FileInputStream负责从文件中读取数据，而FileOutputStream负责向文件中写入数据。
ByteArrayInputStream和ByteArrayOutputStream：ByteArrayInputStream和ByteArrayOutputStream是用于读写字节数组的流。ByteArrayInputStream负责从字节数组中读取数据，而ByteArrayOutputStream负责向字节数组中写入数据。
DataInputStream和DataOutputStream：DataInputStream和DataOutputStream是用于读写基本数据类型的流。DataInputStream提供了readXXX()方法，可以读取int、long、float、double等基本数据类型，而DataOutputStream提供了writeXXX()方法，可以写入int、long、float、double等基本数据类型。
BufferedInputStream和BufferedOutputStream：BufferedInputStream和BufferedOutputStream是用于缓冲读写的流。它们可以提高读写性能，减少读写操作对磁盘的访问次数。BufferedInputStream负责读取数据并将其存储在缓冲区中，而BufferedOutputStream负责将缓冲区中的数据写入到目标中。
ObjectInputStream和ObjectOutputStream：ObjectInputStream和ObjectOutputStream是用于读写Java对象的流。ObjectInputStream负责从输入流中读取对象，而ObjectOutputStream负责将对象写入输出流中。
PipedInputStream和PipedOutputStream：PipedInputStream和PipedOutputStream是用于实现管道通信的流。PipedInputStream负责从管道中读取数据，而PipedOutputStream负责将数据写入管道中。

代码示例

FileInputStream

FileInputStream是InputStream的子类，可以用来读取文件中的数据。例如，可以使用FileInputStream来读取文本文件、音频文件、视频文件等各种类型的文件。

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("test.txt");
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } finally {
            if (fis != null) {
                fis.close();
            }
        }
    }
}

FileOutputStream

FileOutputStream是OutputStream的子类，可以用来向文件中写入数据。例如，可以使用FileOutputStream来写入文本文件、音频文件、视频文件等各种类型的文件。

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("test.txt");
            fos.write("Hello World!".getBytes());
        } finally {
            if (fos != null) {
                fos.close();
            }
        }
    }
}

ByteArrayInputStream

ByteArrayInputStream是InputStream的子类，可以用来从byte数组中读取数据。

import java.io.ByteArrayInputStream;
import java.io.IOException;

public class ByteArrayInputStreamDemo {
    public static void main(String[] args) throws IOException {
        byte[] data = "Hello World!".getBytes();
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        int ch;
        while ((ch = bais.read()) != -1) {
            System.out.print((char) ch);
        }
    }
}

ByteArrayOutputStream

ByteArrayOutputStream是OutputStream的子类，可以用来向byte数组中写入数据。

import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        baos.write("Hello World!".getBytes());
        byte[] data = baos.toByteArray();
        System.out.println(new String(data));
    }
}

FileReader

FileReader是Reader的子类，可以用来读取文本文件中的数据。

import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader fr = null;
        try {
            fr = new FileReader("test.txt");
            int ch;
            while ((ch = fr.read()) != -1) {
                System.out.print((char) ch);
            }
        } finally {
            if (fr != null) {
                fr.close();
            }
        }
    }
}

FileWriter

FileWriter是Writer的子类，可以用来向文本文件中写入数据。

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            fw = new FileWriter("test.txt");
            fw.write("Hello World!");
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

处理流

在Java IO流中，处理流（也称为高级流或缓冲流）是用来对其他节点流进行包装或修饰，以实现各种高级功能的流。

处理流的作用可以分为以下几种：

提高读写效率

缓冲流是处理流的一种，它可以将字节流或字符流包装起来，提高读写效率。例如，使用BufferedInputStream和BufferedOutputStream可以将读写字节流的效率提高，使用BufferedReader和BufferedWriter可以将读写字符流的效率提高。

提供便利的读写功能

处理流提供了很多便利的方法，以方便我们读写数据。例如，使用DataInputStream和DataOutputStream可以方便地读写Java原始数据类型，使用PrintStream可以方便地打印各种数据类型。

提供额外的功能

处理流还可以提供一些额外的功能，例如，使用GZIPInputStream和GZIPOutputStream可以对数据进行压缩，使用ObjectInputStream和ObjectOutputStream可以对Java对象进行读写，使用ZipInputStream和ZipOutputStream可以对ZIP格式的文件进行读写等。

常用的处理流包括：

BufferedReader/BufferedWriter：缓冲字符流
DataInputStream/DataOutputStream：读写Java原始数据类型
ObjectInputStream/ObjectOutputStream：读写Java对象
PrintStream/PrintWriter：打印各种数据类型
GZIPInputStream/GZIPOutputStream：对数据进行压缩
ZipInputStream/ZipOutputStream：对ZIP格式的文件进行读写

需要注意的是，处理流通常是包装节点流而产生的，因此当我们关闭处理流时，底层的节点流也会被关闭。因此，在使用处理流时，不需要显式关闭底层节点流，只需要关闭处理流即可。

代码示例

BufferedInputStream/BufferedOutputStream

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream("source.txt");
            fos = new FileOutputStream("target.txt");
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
        } finally {
            if (bis != null) {
                bis.close();
            }
            if (bos != null) {
                bos.close();
            }
        }
    }
}

DataInputStream/DataOutputStream

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = null;
        DataOutputStream dos = null;
        FileInputStream fis = null;
        DataInputStream dis = null;
        try {
            fos = new FileOutputStream("data.txt");
            dos = new DataOutputStream(fos);
            dos.writeInt(123);
            dos.writeDouble(3.14);
            dos.writeUTF("Hello, World!");
            fis = new FileInputStream("data.txt");
            dis = new DataInputStream(fis);
            int num = dis.readInt();
            double pi = dis.readDouble();
            String str = dis.readUTF();
            System.out.println(num);
            System.out.println(pi);
            System.out.println(str);
        } finally {
            if (dos != null) {
                dos.close();
            }
            if (dis != null) {
                dis.close();
            }
        }
    }
}

InputStreamReader/OutputStreamWriter

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class CharStreamDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        FileOutputStream fos = null;
        OutputStreamWriter osw = null;
        BufferedWriter bw = null;
        try {
            fis = new FileInputStream("source.txt");
            isr = new InputStreamReader(fis, "UTF-8");
            br = new BufferedReader(isr);
            fos = new FileOutputStream("target.txt");
            osw = new OutputStreamWriter(fos, "UTF-8");
            bw = new BufferedWriter(osw);
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
        } finally {
            if (br != null) {
                br.close();
            }
            if (bw != null) {
                bw.close();
            }
        }
    }
}

Java中常见的节点流和处理流

节点流

代码示例

处理流

代码示例