Java IO流的理解及其分类

IO流概述

IO流为程序设计语言提供了程序与外部设备交互的方式。计算机通过数据线与外部设备进行交互，数据线中传输的是比特流，1bit便是一位数据。计算机中更常见的基本单位是字节，使用 8位0或1 组成的一段数据。

IO流的输入还是输出，是相对于程序或者说相对于内存而言，数据从外流到内存，就是输入（读），数据从内存出去，就是输出（写）。

例如，硬盘就是一种输入输出设备，硬盘可以理解为文件系统，具体的对文件系统操作的IO实现类有FileInputStream，FileOutputStream，FileReader，FileWriter。

不带缓冲区的流，只能一个一个字节或字符地读取。带缓冲区的流对象，可以一次读取一个缓冲区，非常高效。 

Reader fw = new FileReader("d://2.txt");
BufferedReader br = new BufferedReader(fw);
String text = br.readLine();   //读取一行，返回字符串，读到文件结尾时，返回null
System.out.println(text);

如果我们需要将对象输出到文件里，或从文件里读入，就需要序列化和反序列化。

public static void main(String[] args) throws IOException, ClassNotFoundException {

        Member member1 = new Member("004","刘七","5151",85,"1000");
        Member member2 = new Member("001","张三","3252",15,"4141");
        Member member3 = new Member("002","李四","4124",32,"5351");
        Member member4 = new Member("003","王五","5158",14,"5335");

        ArrayList<Member> list = new ArrayList<>();
        list.add(member1);
        list.add(member2);
        list.add(member3);
        list.add(member4);
        //对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new        FileOutputStream("d://members.txt"));
        oos.writeObject(list);
        oos.close();
        //对象输入流 
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d://members.txt"));
        //写入是ArrayList，读取也必须是ArrayList，若想读取单个对象，则写入时就应该写入单个对象
        ArrayList<Member> arr = (ArrayList)ois.readObject();
        ois.close();
        System.out.println(arr);

    }

 

管道流：PipedInputStream ，PipedOutputStream 

使用管道通信时，必须将PipedOutputStream和PipedInputStream配套使用。

大致流程：（必须是线程与线程之间通过管道进行通信）

我们在线程A中向PipedOutputStream中写入数据，这些数据会自动的发送到与PipedOutputStream对应的PipedInputStream中，进而存储在PipedInputStream的缓冲中，线程B读取PipedInputStream中的数据。

让两个线程通过管道流进行数据的交互：

public class WriteThread implements Runnable{
    // 管道输出流
    private PipedOutputStream output;
 
    public WriteThread(PipedOutputStream output) {
        this.output = output;
    }
 
    @Override
    public void run() {
        String str = "hello, piped!";
        try {
            // 向管道输入流(PipedInputStream)的缓冲区写入数据
            output.write(str.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭管道输出流
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ReadThread implements Runnable{
    // 管道输入流
    private PipedInputStream input;
 
    public ReadThread(PipedInputStream input) {
        this.input = input;
    }
 
    @Override
    public void run() {
        try {
            // 创建字节数组
            byte[] data = new byte[1024];
            // 将管道输出流内容放入字节数组中
            input.read(data);
            // 字节数组转换为字符串
            String str = new String(data);
            // 打印读取到的管道流内容
            System.out.println("读取到的管道流内容: " + str);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭管道输入流
                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public class PipedTest {
 
    public static void main(String[] args) {
        try {
            //管道输出流和输入流定义
            PipedOutputStream output = new PipedOutputStream();
            PipedInputStream input = new PipedInputStream();
 
            //创建线程的任务对象
            WriteThread writeThread = new WriteThread(output);
            ReadThread readThread = new ReadThread(input);
            //创建线程
            Thread tWrite = new Thread(writeThread);
            Thread tRead = new Thread(readThread);
 
            // 管道输入流和输出流通过connect方法建立关联
            output.connect(input);
 
            //启动线程
            tWrite.start();
            tRead.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

IO流分类：

从操作对象的角度来看：

从数据流动的数据类型来看：