当前位置:天才代写 > tutorial > JAVA 教程 > java io进修(十一) 缓冲输入流的认知、源码和示例

java io进修(十一) 缓冲输入流的认知、源码和示例

2017-11-02 08:00 星期四 所属: JAVA 教程 浏览:58

副标题#e#

BufferedInputStream(缓冲输入流)的认知、源码和示例

本章内容包罗3个部门:BufferedInputStream先容,BufferedInputStream源码,以及BufferedInputStream利用示例。

BufferedInputStream 先容

BufferedInputStream 是缓冲输入流。它担任于FilterInputStream。

BufferedInputStream 的浸染是为另一个输入流添加一些成果,譬喻,提供“缓冲成果”以及支持“mark()标志”和“reset()重置要领”。

BufferedInputStream 本质上是通过一个内部缓冲区数组实现的。譬喻,在新建某输入流对应的BufferedInputStream后,当我们通过read()读取输入流的数据时,BufferedInputStream会将该输入流的数据分批的填入到缓冲区中。每当缓冲区中的数据被读完之后,输入流会再次填凑数据缓冲区;如此重复,直到我们读完输入流数据位置。

BufferedInputStream 函数列表

BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)
     
synchronized int     available()
void     close()
synchronized void     mark(int readlimit)
boolean     markSupported()
synchronized int     read()
synchronized int     read(byte[] buffer, int offset, int byteCount)
synchronized void     reset()
synchronized long     skip(long byteCount)

BufferedInputStream 源码阐明(基于jdk1.7.40)

package java.io;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
     
public class BufferedInputStream extends FilterInputStream {
     
    // 默认的缓冲巨细是8192字节
    // BufferedInputStream 会按照“缓冲区巨细”来逐次的填充缓冲区;
    // 即,BufferedInputStream填充缓冲区,用户读取缓冲区,读完之后,BufferedInputStream会再次填充缓冲区。如此轮回,直到读完数据...
    private static int defaultBufferSize = 8192;
     
    // 缓冲数组
    protected volatile byte buf[];
     
    // 缓存数组的原子更新器。
    // 该成员变量与buf数组的volatile要害字配合构成了buf数组的原子更新成果实现,
    // 即,在多线程中操纵BufferedInputStream工具时,buf和bufUpdater都具有原子性(差异的线程会见到的数据都是沟通的)
    private static final
        AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =
        AtomicReferenceFieldUpdater.newUpdater
        (BufferedInputStream.class,  byte[].class, "buf");
     
    // 当前缓冲区的有效字节数。
    // 留意,这里是指缓冲区的有效字节数,而不是输入流中的有效字节数。
    protected int count;
     
    // 当前缓冲区的位置索引
    // 留意,这里是指缓冲区的位置索引,而不是输入流中的位置索引。
    protected int pos;
     
    // 当前缓冲区的标志位置
    // markpos和reset()共同利用才有意义。操纵步调:
    // (01) 通过mark() 函数,生存pos的值到markpos中。
    // (02) 通过reset() 函数,会将pos的值重置为markpos。接着通过read()读取数据时,就会从mark()生存的位置开始读取。
    protected int markpos = -1;
     
    // marklimit是标志的最大值。
	// 查察本栏目

说明:

要想读懂BufferedInputStream的源码,就要先领略它的思想。BufferedInputStream的浸染是为其它输入流提供缓冲成果。建设BufferedInputStream时,我们会通过它的结构函数指定某个输入流为参数。BufferedInputStream会将该输入流数据分批读取,每次读取一部门到缓冲中;操纵完缓冲中的这部门数据之后,再从输入流中读取下一部门的数据。

为什么需要缓冲呢?原因很简朴,效率问题!缓冲中的数据实际上是生存在内存中,而原始数据大概是生存在硬盘或NandFlash等存储介质中;而我们知道,从内存中读取数据的速度比从硬盘读取数据的速度至少快10倍以上。

那干嘛不爽性一次性将全部数据都读取到缓冲中呢?第一,读取全部的数据所需要的时间大概会很长。第二,内存价值很贵,容量不像硬盘那么大。

下面,我就BufferedInputStream中最重要的函数fill()举办说明。其它的函数很容易领略,我就不具体先容了,各人可以参考源码中的注释举办领略。

fill() 源码如下:

private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    if (markpos < 0)
        pos = 0;
    else if (pos >= buffer.length) {
        if (markpos > 0) {  /* can throw away early part of the buffer */
            int sz = pos - markpos;
            System.arraycopy(buffer, markpos, buffer, 0, sz);
            pos = sz;
            markpos = 0;
        } else if (buffer.length >= marklimit) {
            markpos = -1;   /* buffer got too big, invalidate mark */
            pos = 0;        /* drop buffer contents */
        } else {            /* grow buffer */
            int nsz = pos * 2;
            if (nsz > marklimit)
                nsz = marklimit;
            byte nbuf[] = new byte[nsz];
            System.arraycopy(buffer, 0, nbuf, 0, pos);
            if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
                // Can't replace buf if there was an async close.
                // Note: This would need to be changed if fill()
                // is ever made accessible to multiple threads.
                // But for now, the only way CAS can fail is via close.
                // assert buf == null;
                throw new IOException("Stream closed");
            }
            buffer = nbuf;
        }
    }
     
    count = pos;
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0)
        count = n + pos;
}

按照fill()中的if...else...,下面我们将fill分为5种环境举办说明。

环境1:读取完buffer中的数据,而且buffer没有被标志

执行流程如下,

(01) read() 函数中挪用 fill()

(02) fill() 中的 if (markpos < 0) ...

#p#分页标题#e#

为了利便阐明,我们将这种环境下fill()执行的操纵等价于以下代码:

private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    if (markpos < 0)
        pos = 0;
     
    count = pos;
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0)
        count = n + pos;
}

说明:

这种环境产生的环境是 — — 输入流中有很长的数据,我们每次从中读取一部门数据到buffer中举办操纵。每次当我们读取完buffer中的数据之后,而且此时输入流没有被标志;那么,就接着从输入流中读取下一部门的数据到buffer中。

个中,判定是否读完buffer中的数据,是通过 if (pos >= count) 来判定的;

         判定输入流有没有被标志,是通过 if (markpos < 0) 来判定的。

领略这个思想之后,我们再对这种环境下的fill()的代码举办阐明,就出格容易领略了。

(01) if (markpos < 0) 它的浸染是判定“输入流是否被标志”。若被标志,则markpos大于/便是0;不然markpos便是-1。

(02) 在这种环境下:通过getInIfOpen()获取输入流,然后接着从输入流中读取buffer.length个字节到buffer中。

(03) count = n + pos; 这是按照从输入流中读取的实际数据的几多,来更新buffer中数据的实际巨细。

环境2:读取完buffer中的数据,buffer的标志位置>0,而且buffer中没有多余的空间

执行流程如下,

(01) read() 函数中挪用 fill()

(02) fill() 中的 else if (pos >= buffer.length) ...

(03) fill() 中的 if (markpos > 0) ...

为了利便阐明,我们将这种环境下fill()执行的操纵等价于以下代码:

private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    if (markpos >= 0 && pos >= buffer.length) {
        if (markpos > 0) {
            int sz = pos - markpos;
            System.arraycopy(buffer, markpos, buffer, 0, sz);
            pos = sz;
            markpos = 0;
        }
    }
     
    count = pos;
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0)
        count = n + pos;
}

#p#副标题#e#

说明:

这种环境产生的环境是 — — 输入流中有很长的数据,我们每次从中读取一部门数据到buffer中举办操纵。当我们读取完buffer中的数据之后,而且此时输入流存在标志时;那么,就产生环境2。此时,我们要保存“被标志位置”到“buffer末端”的数据,然后再从输入流中读取下一部门的数据到buffer中。

个中,判定是否读完buffer中的数据,是通过 if (pos >= count) 来判定的;

         判定输入流有没有被标志,是通过 if (markpos < 0) 来判定的。

         判定buffer中没有多余的空间,是通过 if (pos >= buffer.length) 来判定的。

领略这个思想之后,我们再对这种环境下的fill()代码举办阐明,就出格容易领略了。

(01) int sz = pos - markpos; 浸染是“获取‘被标志位置’到‘buffer末端’”的数据长度。

(02) System.arraycopy(buffer, markpos, buffer, 0, sz); 浸染是“将buffer中从markpos开始的数据”拷贝到buffer中(从位置0开始填充,填充长度是sz)。接着,将sz赋值给pos,即pos就是“被标志位置”到“buffer末端”的数据长度。

(03) int n = getInIfOpen().read(buffer, pos, buffer.length - pos); 从输入流中读取出“buffer.length - pos”的数据,然后填充到buffer中。

(04) 通过第(02)和(03)步组合起来的buffer,就是包括了“原始buffer被标志位置到buffer末端”的数据,也包括了“从输入流中新读取的数据”。

留意:执行过环境2之后,markpos的值由“大于0”酿成了“便是0”!

环境3:读取完buffer中的数据,buffer被标志位置=0,buffer中没有多余的空间,而且buffer.length>=marklimit

执行流程如下,

(01) read() 函数中挪用 fill()

(02) fill() 中的 else if (pos >= buffer.length) ...

(03) fill() 中的 else if (buffer.length >= marklimit) ...

#p#分页标题#e#

为了利便阐明,我们将这种环境下fill()执行的操纵等价于以下代码:

private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    if (markpos >= 0 && pos >= buffer.length) {
        if ( (markpos <= 0) && (buffer.length >= marklimit) ) {
            markpos = -1;   /* buffer got too big, invalidate mark */
            pos = 0;        /* drop buffer contents */
        }
    }
     
    count = pos;
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0)
        count = n + pos;
}

说明:这种环境的处理惩罚很是简朴。首先,就是“打消标志”,即 markpos = -1;然后,配置初始化位置为0,即pos=0;最后,再从输入流中读取下一部门数据到buffer中。

环境4:读取完buffer中的数据,buffer被标志位置=0,buffer中没有多余的空间,而且buffer.length<marklimit

执行流程如下,

(01) read() 函数中挪用 fill()

(02) fill() 中的 else if (pos >= buffer.length) ...

(03) fill() 中的 else { int nsz = pos * 2; ... }

为了利便阐明,我们将这种环境下fill()执行的操纵等价于以下代码:

private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    if (markpos >= 0 && pos >= buffer.length) {
        if ( (markpos <= 0) && (buffer.length < marklimit) ) {
            int nsz = pos * 2;
            if (nsz > marklimit)
                nsz = marklimit;
            byte nbuf[] = new byte[nsz];
            System.arraycopy(buffer, 0, nbuf, 0, pos);
            if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
                throw new IOException("Stream closed");
            }
            buffer = nbuf;
        }
    }
     
    count = pos;
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0)
        count = n + pos;
}

说明:

这种环境的处理惩罚很是简朴。

(01) 新建一个字节数组nbuf。nbuf的巨细是“pos*2”和“marklimit”中较小的谁人数。

int nsz = pos * 2;

if (nsz > marklimit)

   nsz = marklimit;

byte nbuf[] = new byte[nsz];

#p#副标题#e#

(02) 接着,将buffer中的数据拷贝到新数组nbuf中。通过System.arraycopy(buffer, 0, nbuf, 0, pos)

(03) 最后,从输入流读取部门新数据到buffer中。通过getInIfOpen().read(buffer, pos, buffer.length - pos);

留意:在这里,我们思考一个问题,“为什么需要marklimit,它的存在到底有什么意义?”我们团结“环境2”、“环境3”、“环境4”的环境来阐明。

假设,marklimit是无限大的,并且我们配置了markpos。当我们从输入流中每读完一部门数据并读取下一部门数据时,都需要生存markpos所标志的数据;这就意味着,我们需要不绝执行环境4中的操纵,要将buffer的容量扩大……跟着读取次数的增多,buffer会越来越大;这会导致我们占据的内存越来越大。所以,我们需要给出一个marklimit;当buffer>=marklimit时,就不再生存markpos的值了。

环境5:除了上面4种环境之外的环境

执行流程如下,

(01) read() 函数中挪用 fill()

(02) fill() 中的 count = pos...

为了利便阐明,我们将这种环境下fill()执行的操纵等价于以下代码:

private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
     
    count = pos;
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0)
        count = n + pos;
}

说明:这种环境的处理惩罚很是简朴。直接从输入流读取部门新数据到buffer中。

示例代码

关于BufferedInputStream中API的具体用法,参考示例代码(BufferedInputStreamTest.java):

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.lang.SecurityException;
     
/**
 * BufferedInputStream 测试措施
 *
 * @author skywang
 */
public class BufferedInputStreamTest {
     
    private static final int LEN = 5;
     
    public static void main(String[] args) {
        testBufferedInputStream() ;
    }
     
    /**
     * BufferedInputStream的API测试函数
     */
    private static void testBufferedInputStream() {
     
        // 建设BufferedInputStream字节约,内容是ArrayLetters数组
        try {
            File file = new File("bufferedinputstream.txt");
            InputStream in =
                  new BufferedInputStream(
                      new FileInputStream(file), 512);
     
            // 从字节约中读取5个字节。“abcde”,a对应0x61,b对应0x62,依次类推...
            for (int i=0; i<LEN; i++) {
                // 若能继承读取下一个字节,则读取下一个字节
                if (in.available() >= 0) {
                    // 读取“字节约的下一个字节”
                    int tmp = in.read();
                    System.out.printf("%d : 0x%s\n", i, Integer.toHexString(tmp));
                }
            }
     
            // 若“该字节约”不支持标志成果,则直接退出
            if (!in.markSupported()) {
                System.out.println("make not supported!");
                return ;
            }
                   
            // 标志“当前索引位置”,即标志第6个位置的元素--“f”
            // 1024对应marklimit
            in.mark(1024);
     
            // 跳过22个字节。
            in.skip(22);
     
            // 读取5个字节
            byte[] buf = new byte[LEN];
            in.read(buf, 0, LEN);
            // 将buf转换为String字符串。
            String str1 = new String(buf);
            System.out.printf("str1=%s\n", str1);
     
            // 重置“输入流的索引”为mark()所标志的位置,即重置到“f”处。
            in.reset();
            // 从“重置后的字节约”中读取5个字节到buf中。即读取“fghij”
            in.read(buf, 0, LEN);
            // 将buf转换为String字符串。
            String str2 = new String(buf);
            System.out.printf("str2=%s\n", str2);
     
            in.close();
       } catch (FileNotFoundException e) {
           e.printStackTrace();
       } catch (SecurityException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }
    }
}

措施中读取的bufferedinputstream.txt的内容如下:

abcdefghijklmnopqrstuvwxyz

0123456789

ABCDEFGHIJKLMNOPQRSTUVWXYZ

运行功效:

0 : 0x61

1 : 0x62

2 : 0x63

3 : 0x64

4 : 0x65

str1=01234

str2=fghij

来历:http://www.cnblogs.com/skywang12345/p/io_12.html

 

    关键字:


天才代写-代写联系方式