Java I/O常用的类结构图

今天读了《Thinking in Java》中的I/O流的章节，整理了下关于I/O流常用的一些类，类图如下：

常用的类大概就是这些，接下来简单的说下这些类的作用，关键的类我会加上代码的实例：

一、先说Java1.0的InputStream和outputStream

这两个类不多说，就是抽象父类。

1、FileInputStream和FileOutputSteam

文件的写入和读出，主要结合BufferedInputStream和BufferedOutputStream使用。

2、ByteArrayInputStream和ByteArrayOutputSteam

主要是对字节数组进行的操作下面是一个实例，结合DataInputStream的使用

package com.example.io.demo.readerTest;


import java.io.*;

/**
 *  @Author: caesar
 *  @Date：2021年01月13日 20:01:03
 *  @Description:
 */
public class Test4 {
    public static void main(String[] args) throws IOException {
        DataInputStream dataInputStream = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream("This is a dog!!!".getBytes())));
        while (dataInputStream.available() != 0){
            System.out.println((char)dataInputStream.readByte());
        }
        dataInputStream.close();
    }
}

3、StringBufferInputSream已经弃用

4、PipedInputSteam和PipedOutputSteam

主要用于两个线程之间来传递数据，尽量不要使用单个线程来操作管道流，容易出现死锁。

package com.example.io.demo.writetest;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

/**
 * @Author: caesar
 * @Date：2021年01月14日 09:01:38
 * @Description: 管道流
 * 官方说明不建议使用单个线程，可能会死锁。所以在实际开发过程中要注意尽量不要写在单个线程中。
 *
 * 另外在jdk1.1中还出现了另外两个管道流：PipedReader和PipedWriter
 *
 * 这两个流是用来传递字符的。在使用范围上只能传递文本文件。不能用来传递多媒体文件。
 * 如果单线程操作，会出现死锁的情况，也就是notifyAll()和wait()循环执行
 */
public class Test4 {
    static class Receiver implements Runnable {
        private PipedInputStream pipedInputStream;

        public Receiver() {
            this.pipedInputStream = new PipedInputStream();
        }

        public PipedInputStream getPipedInputStream() {
            return pipedInputStream;
        }

        @Override
        public void run() {
            byte[] b = new byte[1024];
            int length;
            try {
                while ((length = pipedInputStream.read(b)) != -1) {

                    System.out.println(new String(b,0,b.length));

                }
            } catch (IOException io) {
                System.out.println(io.getMessage());
            }
        }
    }

    static class Send implements Runnable {
        private PipedOutputStream pipedOutputStream;

        public Send() {
            pipedOutputStream = new PipedOutputStream();
        }

        public PipedOutputStream getPipedOutputStream() {
            return pipedOutputStream;
        }

        String s = "This is a luck dog!!!";

        @Override
        public void run() {
            try {
                pipedOutputStream.write(s.getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        Send send = new Send();
        Receiver receiver = new Receiver();
        // 连接管道流
        send.getPipedOutputStream().connect(receiver.getPipedInputStream());
        // 开启线程
        new Thread(send).start();
        new Thread(receiver).start();
    }
}

5、BufferedInputStream和BufferedOutputSteam

主要是缓冲流，先写道缓冲区，可以提升读取和写入的速度，使用广泛，作为装饰者类，可以配合其他的类进行使用

6、DataInputSteam和DataOutputSteam

平台编码不一致的问题，但是必须按照数据存放的位置，来进行读取。。。

package com.example.io.demo.writetest;

import java.io.*;

/**
 *  @Author: caesar
 *  @Date：2021年01月14日 09:01:20
 *  @Description: 平台编码不一致的问题，但是必须按照数据存放的位置，来进行读取。。。
 */
public class Test3 {
    // 数据的存储和恢复
    public static void main(String[] args) throws IOException {
        DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("G://Test/test.txt")));
        dataOutputStream.writeDouble(3.1415926);
        dataOutputStream.writeUTF("This is a good boy!!!");
        dataOutputStream.writeDouble(1.23456789);
        dataOutputStream.writeUTF("This is a dog!!!");
        dataOutputStream.close();
        DataInputStream dataInputStream = new DataInputStream(new BufferedInputStream(new FileInputStream("G://Test/test.txt")));
        System.out.println(dataInputStream.readDouble());
        System.out.println(dataInputStream.readUTF());
        System.out.println(dataInputStream.readDouble());
        System.out.println(dataInputStream.readUTF());
    }
}

二、Java1.1的Reader和Writer

其他的和上面的类都有对应，我说一下特有的，比如说

1、StringReader、StringWriter和PrintWriter（其实也有PrintSteam，在此也说一下）

　  StringReader和StringWriter就是字符串的读取和写入，PrintWriter可以在写入时候，添加内容。

　　

package com.example.io.demo.writetest;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;

/**
 *  @Author: caesar
 *  @Date：2021年01月13日 21:01:09
 *  @Description: PrintWriter简单实现
 */
public class Test2 {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new StringReader("This is a cat!!!"));
        PrintWriter printWriter = new PrintWriter("G://Test/test2.txt");
        int line = 1;
        String s;
        while ((s = bufferedReader.readLine()) != null){
            printWriter.println("第" + (line++) + "行："+s);
        }
        printWriter.close();
        bufferedReader.close();
    }
}

补充：

标准I/O

System.in：没有被包装过的InputStream

System.out、System.err：被PrintStream包装过的OutputStream

InputStreamReder，outputStream转换流：

Scanner中就有System.in的转换流，转化为了Reader，PrintStream中也有转化流转化为了Writer

来看一个我们自己使用的转化流，其实和Scanner类似，只不过，咱可以判断，输入的为空就跳出：

package com.example.io.demo.writetest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Scanner;

/**
 * @Author: caesar
 * @Date：2021年01月14日 16:01:25
 * @Description: 转换流的使用
 */
public class Test5 {
    public static void main(String[] args) {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String s;
        try {
            while ((s = bufferedReader.readLine()) != null && s.length() != 0) {
                System.out.println(s);
            }
        } catch (IOException io) {
            System.out.println(io.getMessage());
        }
        try {
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}