在毕老师的视频中，老师说BufferedInputStream比FileInputStream的效率更高。但是凭什么说BufferedInputStream的读取效率更高呢？在JAVA API中可以看出BufferedInputStream的读取方式也只有一个字节一个字节的读取，为什么会说BufferedInputStream的效率更高呢？

自己亲手测试一下，看下各自所用的时间，一目了然。代码体现：
import java.io.*;
public class CopyTest {
        public static void main(String[] args) throws IOException {
                long start = System.currentTimeMillis();
               
                method();
                method2();
                long end = System.currentTimeMillis();
                System.out.println("共用时：" + (end - start) + "毫秒");
        }

        //高效字节流一次读写一个字节数组
        private static void method() throws IOException {
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                                "d:\\zxmzf.mp3"));
                BufferedOutputStream bos = new BufferedOutputStream(
                                new FileOutputStream("4.mp3"));
               
                byte[] bys = new byte[1024];
                int len = 0;
                while((len=bis.read(bys))!=-1){
                        bos.write(bys, 0, len);
                }
               
                bos.close();
                bis.close();
        }

       

        // 基本字节流一次读写一个字节数组
        private static void method2() throws IOException {
                FileInputStream fis = new FileInputStream("d:\\zxmzf.mp3");
                FileOutputStream fos = new FileOutputStream("2.mp3");

                byte[] bys = new byte[1024];
                int len = 0;
                while ((len = fis.read(bys)) != -1) {
                        fos.write(bys, 0, len);
                }

                fos.close();
                fis.close();
        }

       

这是四中不同输出和输入流对同一文件的读取和复制。时间

package cn.itcast.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
* 字节流复制数据：
* A:基本字节流一次读写一个字节 44813毫秒
* B:基本字节流一次读写一个字节数组 78毫秒
* C:高效字节流一次读写一个字节 438毫秒
* D:高效字节流一次读写一个字节数组 16毫秒
*
* 测试时间
*/
public class CopyMP3Test {
        public static void main(String[] args) throws IOException {
                long start = System.currentTimeMillis();
                // method1();
                // method2();
                // method3();
                method4();
                long end = System.currentTimeMillis();
                System.out.println("供耗时：" + (end - start) + "毫秒");
        }

        //高效字节流一次读写一个字节数组
        private static void method4() throws IOException {
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                                "d:\\zxmzf.mp3"));
                BufferedOutputStream bos = new BufferedOutputStream(
                                new FileOutputStream("4.mp3"));
               
                byte[] bys = new byte[1024];
                int len = 0;
                while((len=bis.read(bys))!=-1){
                        bos.write(bys, 0, len);
                }
               
                bos.close();
                bis.close();
        }

        // 高效字节流一次读写一个字节
        private static void method3() throws IOException {
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                                "d:\\zxmzf.mp3"));
                BufferedOutputStream bos = new BufferedOutputStream(
                                new FileOutputStream("3.mp3"));

                int by = 0;
                while ((by = bis.read()) != -1) {
                        bos.write(by);
                }

                bis.close();
                bos.close();
        }

        // 基本字节流一次读写一个字节数组
        private static void method2() throws IOException {
                FileInputStream fis = new FileInputStream("d:\\zxmzf.mp3");
                FileOutputStream fos = new FileOutputStream("2.mp3");

                byte[] bys = new byte[1024];
                int len = 0;
                while ((len = fis.read(bys)) != -1) {
                        fos.write(bys, 0, len);
                }

                fos.close();
                fis.close();
        }

        // 基本字节流一次读写一个字节
        private static void method1() throws IOException {
                FileInputStream fis = new FileInputStream("d:\\zxmzf.mp3");
                FileOutputStream fos = new FileOutputStream("1.mp3");

                int by = 0;
                while ((by = fis.read()) != -1) {
                        fos.write(by);
                }

                fos.close();
                fis.close();
        }
}

孙宁洋 发表于 2013-5-31 13:01
相当于运砖的说，一次运一块砖和一次运一车砖，那个更有效率呢？其实缓冲区就相当于车，字符的读取也一样 ...

BufferedReader这个我知道，你能写个小程序说明一下BufferedInputStream的高效吗？

相当于运砖的说，一次运一块砖和一次运一车砖，那个更有效率呢？其实缓冲区就相当于车，字符的读取也一样

风云 发表于 2013-5-31 12:57
1，缓冲区：有缓冲区效率比较高，缓冲区ReadLine方法一次读取更多的数据；没有缓冲区是能读一个字节写一个 ...

BufferedInputStream的read()方法不阻塞了吗？

1，缓冲区：有缓冲区效率比较高，缓冲区ReadLine方法一次读取更多的数据；没有缓冲区是能读一个字节写一个字节；
     某些情况下，如果一个程序频繁地操作一个资源（如文件或数据库），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域中读取数据即可，因为读取内存速度会比较快，这样可以提升程序的性能
     缓冲区可以定义一个byte数组,,用来存储读取的数据.什么时候把byte数组存满就写一次.效率比较高减少io流读写的次数

2，区别：FileInputStream是字节流，BufferedInputStream是字节缓冲流，使用BufferedInputStream读资源比FileInputStream读取资源的效率高（BufferedInputStream的read方法会读取尽可能多的字节），且FileInputStream对象的read方法会出现阻塞

骑上最爱 发表于 2013-5-31 12:50
虽然是一个一个读的，但是它的内部是把对到是字符先存起来，然后一次性的返还给你。 ...

写个小程序，说明一下好吗？非常感谢。

虽然是一个一个读的，但是它的内部是把对到是字符先存起来，然后一次性的返还给你。

BufferedInputStream流数据首先保存进入缓冲区，其后的操作直接在缓冲区中完成。
FileInputStream对象的read方法会出现阻塞。BufferedInputStream是FileInputStream的一个装饰类