• Java IO流部分源码解析

    Java IO流部分源码解析

    前言，很多东西实际上是自己闲着没事去看看底层是怎么实现的，很多地方可能讲的并不是很详细或者会出现错误，还是要相信自己的判断(๑╹ヮ╹๑)ﾉ Studying makes me happy

    目录

    1. Java IO流源码

    1.1字节流

    1.1.1 InputStream/OutputStream

    （1）InputStream

    • 静态常量

      • private static final int MAX_SKIP_BUFFER_SIZE = 2048;

      • MAX_SKIP_BUFFER_SIZE用于确定跳过时要使用的最大缓冲区大小

    • 抽象方法int read()

      • public abstract int read() throws IOException;

      • 此方法作用为读取单个字节，返回整数类型，范围为-1~255

      • 实际上该方法只有在FileInputStream中通过本地方法实现

    • int read(byte b[], int off, int len)

      • 从输入流中读取len个字节，从off位开始，依次存储到数组中

      • 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;
}
        • 该方法首先会对传入byte数组以及开始位置，长度进行检查，不合理会抛出相应的异常
        • 调用read()方法读取第一个字节，如果为没有可读字节直接返回-1，如果有则存入数组起始位off
        • 循环调用read()方法，将其转换为byte类型存入传入的数组
        • 返回读取的字节数

    • int read(byte b[])

      • public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
    }

      • 0作为起始位，数组.length作为终止位，调用read(b, 0, b.length)方法

    • long skip(long n)

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

      • 此方法作用为跳过并丢弃掉来自输入流的n字节数据，并返回实际上跳过的字节数量

        • 首先方法对传入的跳过的字节数进行检查
        • 使用size=(MAX_SKIP_BUFFER_SIZE, remaining)的最小值作为要跳过的字节数
          • 实际上该值只是为了确定之后缓存数组的长度，防止长度过大无法开辟空间
        • 之后该方法是采用新建一个数组对象，以0为起始位，以(size, remaining)的较小值来作为读取长度，如果实际上读取的字节数已经小于0则直接退出循环，否则remaining -= nr,记录剩余的还需跳过的字节数
        • 返回传入的要跳过的字节数n与剩余还需跳过的字节数remain的差值，即实际上跳过的字节数

    • int available()

      • 该方法返回可以从输入流中读取或者跳过的字节数的估计值
      • 实际上在InpuStream中直接返回0，需要子类去重写该方法

    • void close()

      • 该方法作用为关闭输入流，是对Closeable接口的实现
      • 实际上该方法方法体并没有内容，需要子类重写该方法

    • void mark(int readlimit)

      • 该方法的作用为标记输入流的当前位置，对于rese()方法的后续调用会将该流重新定位在最后一个标记位，以便于重新读取相同的字节

        • readlimit参数表示在标记位无效之前可以再读取多少个字节
        • 如果输入流读取字节数超过该参数，则流不会存储任何数据
      • public synchronized void mark(int readlimit) {}
        • 该方法方法体没有内容
        • 该方法被synchronized修饰，对于多个线程来说需要排队访问该方法，保证一致性

    • void reset()

      • 该方法将此流重新定位到上次调用mark()方法标记的位置

      • 如果方法markSupported()返回true ，则：

        • 如果方法mark由于上述流创建没有被调用，或从流中读取的字节数，比mark最后调用的参数大，那么IOException可能会被抛出。
        • 如果这样的IOException不抛出，那么流被重置为一个状态，使得所有字节读取自最近一次调用mark （或自文件开始，如果mark尚未调用）将被重新提供后续read方法的呼叫者，之后是到重置到的调用mark标记位的下一个输入数据的字节。

        如果方法markSupported()返回false ，那么：

        • 致电reset可能会抛出一个IOException 。
        • 如果没有抛出IOException ，则流将重置为固定状态，这取决于输入流的特定类型及其创建方式。 将提供给read方法的后续调用者的read取决于输入流的特定类型。

      • 在InpuStream中总是抛出异常IOException("mark/reset not supported")，需要子类重写该方法

    • boolean markSupported()

      • 表示是否支持标记，重置功能
      • 在InoutStream中返回false，需要子类取根据情况重写

    （2）OutputStream

    • 接口实现

    • 抽象接口void write(int b)

      • 写入一个字节，子类去实现，该接口实际上是在FileOutputStream中通过本地方法来实现

    • void write(byte b[],int off,int len)

      • 以off为起始位，将数组中len个字节写入到输出流

        public void write(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if ((off < 0) || (off > b.length) || (len < 0) ||
                   ((off + len) > b.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        }
        for (int i = 0 ; i < len ; i++) {
            write(b[off + i]);
        }
    }
        • 首先对参数进行检测，如果不合要求抛出相应异常
        • 采用for循环调用write(int)方法来写入字节

    • void write(byte b[])

      • 调用write(byte b[],0,,b.length)

    • void flush()

      • 将缓冲区的数据写入到输出流，实现了Flushable接口
      • 在OutputStream中方法体没有内容，子类去实现

    • void close()

      • 关闭输出流，是释放系统资源，实现了Closeable接口，进而实现了AutoCloseable接口，可以用try with resouces语法实现自动关闭
      • 在OutputStream中方法体没有内容，子类去实现

    1.1.2 FileInputStream/FileOutputStream

    作为输入输出流的最终实现类，实际上是通过FileChanel对象来进行文件的读取的，有时间补上

    1.1.3 FilterInputStream/OutPutStream

    （1）FilterInputStream

    • 该类作为所有输入处理流的父类，并没有开放构造方法，因此也不能通过new 来创建该类对象

    • 源码：

      public class FilterInputStream extends InputStream{
    
    protected volatile InputStream in;
    protected FilterInputStream(InputStream in) {
        this.in = in;
    }

    ...
    
}

    • 该类中的所有方法均调用的属性InputStream in的方法，没有做特别处理，该类也没有增加新的方法

    （2）FilterOutputStream

    该类作为所有输出处理流的父类，开放构造方法，因此可以通过new 来创建该类对象

    重写的方法：

    • public class FilterOutputStream extends OutputStream {

    protected OutputStream out;

    public FilterOutputStream(OutputStream out) {
        this.out = out;
    }
   
    ...
        
    public void write(byte b[], int off, int len) throws IOException {
        if ((off | len | (b.length - (len + off)) | (off + len)) < 0)
            throw new IndexOutOfBoundsException();

        for (int i = 0 ; i < len ; i++) {
            write(b[off + i]);
        }
    }
    
    public void close() throws IOException {
        try (OutputStream ostream = out) {
            flush();
        }
    }
    
}
      • close()方法将在try()中使用一个引用指向该对象的out，然后进行flush()方法输出所有缓存中的数据，当结束后会自动调用out.close()方法（try with resource 语法）进行关闭

    1.1.4 DataInputStream/DataOutputStream

    （1）DataInputStream

    • 该类为FilterInputStream的直接子类

    • read整数方法读取整数的实现方式，以readInt为例

      public final int readInt() throws IOException {
    int ch1 = in.read();
    int ch2 = in.read();
    int ch3 = in.read();
    int ch4 = in.read();
    if ((ch1 | ch2 | ch3 | ch4) < 0)
        throw new EOFException();
    return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
}
      • 该方法读取4个字节，第一个字节左移24位，作为int的第一个字节，第二个字节左移16位，作为整数的第二个字节，...,最后一个字节作为整数的的最低字节，相加得到该整数的值
      • 其它整数数据的读取与之类似

    • read浮点数方法读取浮点数的实现方式

          public final float readFloat() throws IOException {
        return Float.intBitsToFloat(readInt());
    }

    public final double readDouble() throws IOException {
        return Double.longBitsToDouble(readLong());
    }
      • 实际上两者都是以读取相应字节数的整数类型来实现，通过包装类的静态方法（为本地方法）来进行转换

    • readLine()方法通过循环调用read()方法读入字节，遇到-1或者' '或者' '结束，然后将读取的字节构建String对象实现读取一行的作用，如果没有数据则返回null

    • readUTF()实际上返回了return readUTF(this)，readeUTF(DataInput in)较为复杂，有兴趣的可以自己看看源码，水平有限，先标记一下 ：）//TODO

    （2）DataOuputStream

    • 该类为FilterOutputStream的直接子类

    • write整数方法读取整数的实现方式，以writeInt为例

      public final void writeInt(int v) throws IOException {
    out.write((v >>> 24) & 0xFF);
    out.write((v >>> 16) & 0xFF);
    out.write((v >>>  8) & 0xFF);
    out.write((v >>>  0) & 0xFF);
    incCount(4);
}
      • 该方法通过右移的方法依次从高到低获取整数的不同字节，每个字节转为byte，最后写入这4个字节，实现整数的存储
      • 其他整数写入的方法与该方法相似

    • write浮点数

      public final void writeFloat(float v) throws IOException {
    writeInt(Float.floatToIntBits(v));
}

public final void writeDouble(double v) throws IOException {
    writeLong(Double.doubleToLongBits(v));
}
      • 该类方法通过调用包装类的静态方法将浮点数转为相应的整数，利用写入整数的方法来写入该浮点数的数据

    • writeBytes(String s)与writeChars(String s)

      public final void writeBytes(String s) throws IOException {
    int len = s.length();
    for (int i = 0 ; i < len ; i++) {
        out.write((byte)s.charAt(i));
    }
    incCount(len);
}


public final void writeChars(String s) throws IOException {
    int len = s.length();
    for (int i = 0 ; i < len ; i++) {
        int v = s.charAt(i);
        out.write((v >>> 8) & 0xFF);
        out.write((v >>> 0) & 0xFF);
    }
    incCount(len * 2);
}
      • 从源码中可以看出writeBytes会将字符串的每个字符(2字节)强制转换为byte类型，也就是说超过单个字节的字符会出现乱码现象
      • 而writeChars会以一个char对应两个字节的方式正常存入，不会出现乱码问题

    • writeUTF(String s)也是调用其静态方法static int writeUTF(String str, DataOutput out)情况较为复杂，能力有限，不再此处赘述。

    1.1.5 BufferedInputStream/BufferedOutputStream

    （1）BufferedInputStream

    该类通过维护一个protected volatile byte buf[]来作为缓冲区，来暂时存储读入的数据，等符合条件后统一输入

    • 属性

      private static int DEFAULT_BUFFER_SIZE = 8192; // 默认缓冲区大小

private static int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8; // 最大缓冲区大小

protected volatile byte buf[]; // 缓冲数组

// 为buf提供compareAndSet的原子更新程序。这是必要的，因为关闭可以是异步的。我们使用buf[]的空值作为此流已关闭的主要指示器。（关闭时，“in”字段也将为空。）
private static final
    AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =
    AtomicReferenceFieldUpdater.newUpdater
    (BufferedInputStream.class,  byte[].class, "buf");

protected int count;

protected int pos; // 从缓冲区要读取的下标位置

protected int markpos = -1; // 标记位

protected int marklimit; // 标记后限制的读取量

    • fill方法

      private InputStream getInIfOpen() throws IOException {
    InputStream input = in;
    if (input == null)
        throw new IOException("Stream closed");
    return input;
}

/**
     * Check to make sure that buffer has not been nulled out due to
     * close; if not return it;
     */
private byte[] getBufIfOpen() throws IOException {
    byte[] buffer = buf;
    if (buffer == null)
        throw new IOException("Stream closed");
    return buffer;
}


private void fill() throws IOException {
	// 太长而且比较繁琐，只了解功能即可
}
      • fill方法使用更多数据填充缓冲区（通过read方法读取到buf数组中），同时考虑到洗牌和处理标记的其他技巧。假设它是由同步方法调用的。此方法还假设所有数据都已读入，因此pos>count。

    • read方法

      public synchronized int read() throws IOException {
    if (pos >= count) {
        fill();
        if (pos >= count)
            return -1;
    }
    return getBufIfOpen()[pos++] & 0xff;
}

/**
     * Read characters into a portion of an array, reading from the underlying
     * stream at most once if necessary.
     */
private int read1(byte[] b, int off, int len) throws IOException {
    int avail = count - pos;
    if (avail <= 0) {
        /* If the requested length is at least as large as the buffer, and
               if there is no mark/reset activity, do not bother to copy the
               bytes into the local buffer.  In this way buffered streams will
               cascade harmlessly. */
        if (len >= getBufIfOpen().length && markpos < 0) {
            return getInIfOpen().read(b, off, len);
        }
        fill();
        avail = count - pos;
        if (avail <= 0) return -1;
    }
    int cnt = (avail < len) ? avail : len;
    System.arraycopy(getBufIfOpen(), pos, b, off, cnt);
    pos += cnt;
    return cnt;
}

public synchronized int read(byte b[], int off, int len)
        throws IOException
    {
        getBufIfOpen(); // Check for closed stream
        if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        int n = 0;
        for (;;) {
            int nread = read1(b, off + n, len - n);
            if (nread <= 0)
                return (n == 0) ? nread : n;
            n += nread;
            if (n >= len)
                return n;
            // if not closed but no bytes available, return
            InputStream input = in;
            if (input != null && input.available() <= 0)
                return n;
        }
    }
      • read()方法首先会检查下标位置，然后读取字节进行填充到buf中
      • read方法为synchronized所修饰，该方法会执行过程中会检查标记位，读取位，然后循环调用read1去写入数组，返回写入的字节数量

    • 其他

      public synchronized int available() throws IOException {
    int n = count - pos;
    int avail = getInIfOpen().available();
    return n > (Integer.MAX_VALUE - avail)
        ? Integer.MAX_VALUE
        : n + avail;
}

public synchronized void mark(int readlimit) {
    marklimit = readlimit;
    markpos = pos;
}

public synchronized void reset() throws IOException {
    getBufIfOpen(); // Cause exception if closed
    if (markpos < 0)
        throw new IOException("Resetting to invalid mark");
    pos = markpos;
}
      • available()方法会检查内部输入流是否有效，长度是否在合理范围内
      • mark方法会将标记位设为当前要读取的下标位，将限制读取的字节数设为传入值
      • reset方法将要读取的下标位设为标记位

    • close方法

      public void close() throws IOException {
    byte[] buffer;
    while ( (buffer = buf) != null) {
        if (bufUpdater.compareAndSet(this, buffer, null)) {
            InputStream input = in;
            in = null;
            if (input != null)
                input.close();
            return;
        }
        // Else retry in case a new buf was CASed in fill()
    }
}
      • 该方法会通过bufUpdater的compareAndSet方法检查执行到该处时，数组是否有写入，如果没变化，就将buf设为null,之后再尝试将in设为null，如果不为null则进行close方法

    （2）BufferedOutputStream

    该类实际上是通过维护了一个protected byte buf[]来作为缓冲区，来暂时存储要写入的数据，等到最后统一写出,通过属性int count来作为当前位置

    在构造方法中的size参数实际上被作为创建数组的大小，默认size=8192

    重写的方法：

    • write(int b)方法

      public synchronized void write(int b) throws IOException {
    if (count >= buf.length) {
        flushBuffer();
    }
    buf[count++] = (byte)b;
}
      • 该方法会将传入字节存进buf数组中，并使count+1
      • 如果count已经超出buf数组的长度，则直接通过flushBuffer方法来写出数据

    • flush方法

      /** Flush the internal buffer */
private void flushBuffer() throws IOException {
    if (count > 0) {
        out.write(buf, 0, count);
        count = 0;
    }
}

public synchronized void flush() throws IOException {
       flushBuffer();
       out.flush();
}

    • close方法

      public void close() throws IOException {
    try (OutputStream ostream = out) {
        flush();
    }
}
      • 这是FilterOutputStream的方法，在BufferedOutputStream中该方法并没有重写
      • 实际上该方法会自动调用flush方法：先在try语句中声明一个引用，在调用BufferedOutputStream的flush方法输出buffer中的数据，最后会自动关闭（隐式执行out.close()方法）
  • 相关阅读:
    linux网络编程-socket(36)
    linux网络编程-socket(2)
    linux网络编程-socket(1)
    jni不通过线程c回调java的函数
    jni 字符串的梳理 2 字符串的处理操作
    jni 字符串的梳理
    android studio 中jni底层日志的打印
    事件冒泡与事件捕获
    盒子模型
    比较好的前端面试题
  • 原文地址：https://www.cnblogs.com/nishoushun/p/12797305.html
Copyright © 2020-2023  润新知