IO流(二) Java中的传统IO

public abstract class InputStream implements Closeable {

	// 用于确定要使用的最大缓冲区大小，调用skip方法时使用
	private static final int MAX_SKIP_BUFFER_SIZE = 2048;

	// 读取方法，需要子类重写
	public abstract int read() throws IOException;

	// 读取参数数组大小的字节，并将读取结果填充到参数中
	public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
    }

    // 读取指定长度的字节，并将读取结果填充到参数数组中，从off坐标开始，填充len位
    // 由于方法是循环读取，每次都需要与内核交互一次，因此效率很低，子类通常会重写
    public int read(byte b[], int off, int len) throws IOException {
        // 省略...
    }

    // 跳过n位字节，最多不能超过MAX_SKIP_BUFFER_SIZE
    public long skip(long n) throws IOException {
        // 省略...
    }

	// 返回读取的目标，一共有多少字节，需要子类重写
    public int available() throws IOException {
        return 0;
    }

    // 关闭流
    public void close() throws IOException {}

	// 标记当前读取的位置，方法为空需要子类重写
    public synchronized void mark(int readlimit) {}

    // 将读取的坐标重置到mark的位置，方法默认抛异常需要子类重写
    public synchronized void reset() throws IOException {
        throw new IOException("mark/reset not supported");
    }

    // 是否支持mark，默认不支持，子类根据需要重写
    public boolean markSupported() {
        return false;
    }

public abstract class OutputStream implements Closeable, Flushable {

    // 写入单个字节，参数是int类型，估计是想和read对应上吧
	public abstract void write(int b) throws IOException;

    // 写入多个字节
	public void write(byte b[]) throws IOException {
        write(b, 0, b.length);
    }

    // 写入多个字节，指定范围，内部还是for循环一个个写
    public void write(byte b[], int off, int len) throws IOException {
        // 省略...
    }

    // 刷新
    public void flush() throws IOException {
    }

    // 关闭流
    public void close() throws IOException {
    }

public class Main {

    public static void main(String[] args) throws Exception{

        // 创建输入流
        FileInputStream fileInputStream = new FileInputStream("/Users/lvtao/Downloads/test");

        // 一次性读取数据，放入数组
        byte[] bytes = new byte[fileInputStream.available()];
        fileInputStream.read(bytes);

        // 指定字符集并转String
        String result = new String(bytes, "UTF-8");
        System.out.println(result);

        // 打印读取结果
        fileInputStream.close();
    }
}

public abstract class Reader implements Readable, Closeable {

    // 锁对象，用于保证部分操作的线程安全
    protected Object lock;

    // 空构造器，将自身作为锁
    protected Reader() {
        this.lock = this;
    }

    // 指定一个对象作为锁对象
    protected Reader(Object lock) {
        if (lock == null) {
            throw new NullPointerException();
        }
        this.lock = lock;
    }

    // 读取多个字符到CharBuffer中，内部调用抽象read方法
    public int read(java.nio.CharBuffer target) throws IOException {
        // 省略...
    }

    // 读取单个字符，内部调用抽象read方法
    public int read() throws IOException {
        // 省略...
    }

    // 读取多个字符，内部调用抽象read方法
    public int read(char cbuf[]) throws IOException {
        return read(cbuf, 0, cbuf.length);
    }

    // 读取多个字节，需要子类重写
    abstract public int read(char cbuf[], int off, int len) throws IOException;

    // 最多跳过的缓冲数量
    private static final int maxSkipBufferSize = 8192;

    // 跳过数组
    private char skipBuffer[] = null;

    public long skip(long n) throws IOException {
        // 省略...
    }

    public boolean ready() throws IOException {
        return false;
    }

    // 重复读取那一套
    public boolean markSupported() {
        return false;
    }

    // 重复读取那一套
    public void mark(int readAheadLimit) throws IOException {
        throw new IOException("mark() not supported");
    }

    // 重复读取那一套
    public void reset() throws IOException {
        throw new IOException("reset() not supported");
    }

    // 关闭流
    abstract public void close() throws IOException;
}

public abstract class Writer implements Appendable, Closeable, Flushable {

    private char[] writeBuffer;

    private static final int WRITE_BUFFER_SIZE = 1024;

    protected Object lock;protected Writer() {
        this.lock = this;
    }

    protected Writer(Object lock) {
        if (lock == null) {
            throw new NullPointerException();
        }
        this.lock = lock;
    }

    public void write(int c) throws IOException {
        synchronized (lock) {
            if (writeBuffer == null){
                writeBuffer = new char[WRITE_BUFFER_SIZE];
            }
            writeBuffer[0] = (char) c;
            write(writeBuffer, 0, 1);
        }
    }

    public void write(char cbuf[]) throws IOException {
        write(cbuf, 0, cbuf.length);
    }

    abstract public void write(char cbuf[], int off, int len) throws IOException;

    public void write(String str) throws IOException {
        write(str, 0, str.length());
    }

    public void write(String str, int off, int len) throws IOException {
        synchronized (lock) {
            char cbuf[];
            if (len <= WRITE_BUFFER_SIZE) {
                if (writeBuffer == null) {
                    writeBuffer = new char[WRITE_BUFFER_SIZE];
                }
                cbuf = writeBuffer;
            } else {
                cbuf = new char[len];
            }
            str.getChars(off, (off + len), cbuf, 0);
            write(cbuf, 0, len);
        }
    }

    public Writer append(CharSequence csq) throws IOException {
        if (csq == null)
            write("null");
        else
            write(csq.toString());
        return this;
    }

    public Writer append(CharSequence csq, int start, int end) throws IOException {
        CharSequence cs = (csq == null ? "null" : csq);
        write(cs.subSequence(start, end).toString());
        return this;
    }

    public Writer append(char c) throws IOException {
        write(c);
        return this;
    }

    abstract public void flush() throws IOException;

    abstract public void close() throws IOException;
}

public static void main(String[] args) throws Exception{

    // 1.创建一个Charset抽象类的UTF-8字符集实现类
    Charset charset = Charset.forName("UTF-8");

    // 2.1创建UTF-8字符集的编码对象
    CharsetEncoder encoder = charset.newEncoder();

    // 2.2要写入的内容
    String text = "1949年10月1日,中华人民共和国成立";
    CharBuffer charBuffer = CharBuffer.wrap(text.toCharArray());

    // 2.3将包含汉字的字符串，编码成字节，供后续写入
    ByteBuffer encodeByteBuffer = encoder.encode(charBuffer);

    // 3.1创建UTF-8字符集的解码对象
    CharsetDecoder decoder = charset.newDecoder();

    // 3.2读取字节内容并转化为字符
    CharBuffer decoderCharBuffer = decoder.decode(encodeByteBuffer);

    // 3.3打印读取结果
    System.out.println(decoderCharBuffer.toString());
}