Java-IO之BufferedInputStream（缓冲输入流）

本文主要是介绍Java-IO之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)  

示例代码：

public class BufferedInputStreamTest {  
  
    private static final int LEN = 5;  
  
    public static void main(String[] args) {  
        testBufferedInputStream() ;  
    }  
    private static void testBufferedInputStream() {  
  
        // 创建BufferedInputStream字节流，内容是ArrayLetters数组  
        try {  
            File file = new File("file.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();  
        }  
    }  
}  

基于JDK8的BufferInputStream代码：

public class BufferedInputStream extends FilterInputStream {  
  
    private static int DEFAULT_BUFFER_SIZE = 8192;//默认缓冲区大小为8X1024  
    private static int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;  
    protected volatile byte buf[]; //缓冲数组  
  
    /** 
     * Atomic updater to provide compareAndSet for buf. This is 
     * necessary because closes can be asynchronous. We use nullness 
     * of buf[] as primary indicator that this stream is closed. (The 
     * "in" field is also nulled out on close.) 
     */  
    private static final AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =  
  

这篇关于Java-IO之BufferedInputStream（缓冲输入流）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---