java基础类库学习（六.3）字节流 字符流（输入输出）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/strivenoend/article/details/83755173

前言：

字节流和字符流的操作方式几乎相同，区别只是操作的数据单元不同而已

字节流操作的数据单元是字节8位，字符流操作的数据单元是字符16位

输入流

字符输入流/字节输入流源码（输入流的抽象基类）

InputStream

public abstract class InputStream implements Closeable {

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

public void close() throws IOException {}

public synchronized void mark(int readlimit) {}

public int read(byte b[], int off, int len) throws IOException {
    if (b == null) {
        throw new NullPointerException();
    } else if (off < 0 || len < 0 || len > b.length - off) {
        throw new IndexOutOfBoundsException();
    } else if (len == 0) {
        return 0;
    }

    int c = read();
    if (c == -1) {
        return -1;
    }
    b[off] = (byte)c;

    int i = 1;
    try {
        for (; i < len ; i++) {
            c = read();
            if (c == -1) {
                break;
            }
            b[off + i] = (byte)c;
        }
    } catch (IOException ee) {
    }
    return i;
}

public long skip(long n) throws IOException {

    long remaining = n;
    int nr;

    if (n <= 0) {
        return 0;
    }

    int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);
    byte[] skipBuffer = new byte[size];
    while (remaining > 0) {
        nr = read(skipBuffer, 0, (int)Math.min(size, remaining));
        if (nr < 0) {
            break;
        }
        remaining -= nr;
    }

    return n - remaining;
}

  public boolean markSupported() {
        return false;
    }

}

Reader

public abstract class Reader implements Readable, Closeable {

protected Object lock;

protected Reader() {
    this.lock = this;
}

public int read(java.nio.CharBuffer target) throws IOException {
    int len = target.remaining();
    char[] cbuf = new char[len];
    int n = read(cbuf, 0, len);
    if (n > 0)
        target.put(cbuf, 0, n);
    return n;
}

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

public boolean markSupported() {
    return false;
}

   abstract public void close() throws IOException;

}
可以发现Reader和InputStream中的方法几乎一致

输出流

字节输出流/字符输出流（输出流的抽象基类）

OutputStream

public abstract class OutputStream implements Closeable, Flushable {
 

public abstract void write(int b) throws IOException;

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

public void flush() throws IOException {
}

 public void close() throws IOException {
    }

}

Writer

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

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

  abstract public void close() throws IOException;

}