java BufferedInput BufferedOutputStream

使用FileInputStream读取文件数据的时候如何读取效率是最高？

使用字节数组作为缓冲区读取的效率是最高的。

我们知道使用缓冲字节数组读取文件的效率最高，sun也知道使用缓冲字节数组读取的效率高，这时候sun为了方便我们
工作，编写一个缓冲输入字节流给我去使用，

缓冲输入字节流的作用：

提高我们读取文件数据的效率。

输入字节流的体系：

----------| InputStream 抽象类所有输入字节流的基类
--------------| FileInputStream 读取文件数据的输入字节流
--------------|BufferedInputStream 缓冲输入字节流 该类的本质其实只是在内部维护了一个8kb的字节数组而已。主要是为了提高我们的读取文件的效率。

凡是缓冲流都没有读写文件的能力,在使用之读写数据的时候,其实都是依赖着其绑定的FileInput/OutputStream

BuffereInputStream注意的事项：

BuffereInputStream 的close方法实际上关闭的就是你传递进去的FileInputStream对象。

public class Demo1 {

    public static void main(String[] args) throws IOException {
        //readTest();
    }

    public static void readTest() throws  IOException {
        //第一步：找到目标文件
        File file = new File("F:\\a.txt");
        //第二步：建立文件与程序的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //第三部：建立缓冲输入字节流
        /*
            疑问： 为什么创建BufferedInputStream对象需要传入一个InputStream的对象呢？
                BufferedInputStream没有读取文件 数据的能力，但是又要读取文件的数据，这时候只能依赖一个具备
                读取文件数据能力的对象。
            
         */
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        //读取文件数据
        int content = 0; 
        /*
            疑问： BufferedInputStream 的read方法每次只是读取一个字节的数据，FileInputStream的read方法每次也是读取一个字节的数据
            那么为什么说BufferedInputStream提高了读取的效率呢？
         */
        while((content = bufferedInputStream.read())!=-1){
            System.out.print((char)content);
        }
    
        //关闭资源   
        bufferedInputStream.close();
    }
    
    //不使用缓冲流读取的(据说这种方式效率更高)
    public static void readTest2() throws IOException{
        //第一步：找到目标文件
        File file = new File("F:\\a.txt");
        //第二步：建立文件与程序的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        byte[] buf = new byte[8192];
        int length = 0 ; 
        while((length = fileInputStream.read(buf))!=-1){
            System.out.println(new String(buf,0,length));
        }
        fileInputStream.close();
        
    }
}

查看BufferedInputStream内部结构

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

/**
*  仅仅就是返回了buf而已
*/
private byte[] getBufIfOpen() throws IOException {
        byte[] buffer = buf;
        if (buffer == null)
            throw new IOException("Stream closed");
        return buffer;
    }
}

/*
pos    :当前读取buffer[]指向的位置
count  :当前buffer[]的容量
buf    :BufferedInputSteam中维护的缓存区buffer[]

过程是:
使用该read()函数,其内部会先从文件中尽量读取8kb数据来填充其维护的buffer[];
然后再依次返回该buffer[]中的一个字节,直到buffer[]被读完,再循环从文件中读取数据........
*/

缓冲输出字节流：为了提高写文件的效率。

---------| OutputStream 抽象类，所有输出字节流的基类。
-------------| FileOutputStream 向文件写出数据的输出字节流对象。
-------------| BufferedOutputStream 缓冲输出字节流，为了提高写文件数据的效率。

BufferedOutputStream 需要注意的事项：

使用BufferedOutputStream的write方法时候，数据其实是写入了BufferedOutputStream内部维护的字节数组中，只有你调用BufferedOutputStream的close方法或者是flush方法数据才会真正的写到硬盘上去或者内部维护的字节数组已经存储满数据了，这时候数据也会写到硬盘上去。
BufferedOutputStream 的close方法实际上关闭的就是你传入的OutputStream对象的close方法。

public class Demo2 {

    public static void main(String[] args) throws IOException {
    
        //找到目标文件对象
        File file = new File("f:\\a.txt");
        //建立数据的输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        //建立缓冲输出字节流
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        //写数据
        String data = "hello world";
        bufferedOutputStream.write(data.getBytes());
        
//      bufferedOutputStream.flush(); //把缓冲字节数组的数据写到硬盘上去。(立即)
        bufferedOutputStream.close();//(关闭流时)
    
    }
}