代码有点长，不过加了点注释。这是看视频后的练习，跟老师的代码比较也没发现什么不一样，但就是比老师的运行时间长，复制个500多kb的歌曲跑了12秒，:time:检查半天没发现是哪 的问题，各位帮看哈

1. import java.io.IOException;
   
2. import java.io.InputStream;
   
3. 
   
4. public class myBufferedInputStream {
   
5.         private InputStream in;
   
6.         private byte[] buf = new byte[1024];
   
7.         private int count = 0, pos = 0;
   
8. 
   
9.         myBufferedInputStream(InputStream in) {
   
10.                 this.in = in;
    
11.         }
    
12.         public int myRead() throws IOException {
    
13.                 if (count == 0) {
    
14.                         count = in.read(buf);//这里是一次读满一组数组吧？？那count为1024
    
15.                         if (count < 0) {
    
16.                                 return -1;
    
17.                         }
    
18.                         pos = 0;//指针归零
    
19.                         byte b = buf[pos];//按个取出，这里取buf[0]吧
    
20.                         count--;//总数减一个
    
21.                         pos++;//指针移位
    
22.                         // System.out.println(b);
    
23.                         return b * 255;//将将int转换为byte
    
24.                 }
    
25.                 if (count > 0) {
    
26.                         byte b = buf[pos];//数组还没取完
    
27.                         count--;
    
28.                         pos++;
    
29.                         return b * 0xff;//将将int转换为byte
    
30.                 }
    
31.                 return -1;
    
32.         }
    
33.         public void myClose() {
    
34.                 try {
    
35.                         in.close();
    
36.                 } catch (IOException e) {
    
37.                         // TODO Auto-generated catch block
    
38.                         e.printStackTrace();
    
39.                 }
    
40.         }
    
41. }
    
42. import java.io.*;
    
43. 
    
44. public class TestBufInps {
    
45.         public static void main(String[] args) {
    
46.                 long start = System.currentTimeMillis();//开始时间
    
47.                 myBufferedInputStream myBuf = null;//自定义缓冲
    
48.                 OutputStream out = null;
    
49.                 try {
    
50.                         myBuf = new myBufferedInputStream(new FileInputStream("d:\\13.mp3"));
    
51.                         out = new FileOutputStream("d:\\14.mp3");//指定位置
    
52.                         int len = 0;
    
53.                         while ((len = myBuf.myRead()) != -1) {//调用自己的read方法
    
54.                                 out.write(len);//写入指定位置，这里有一个自动转换为的操作
    
55.                         }
    
56.                         out.flush();//保存
    
57.                 } catch (IOException e) {
    
58.                         throw new RuntimeException("Error");
    
59.                 } finally {
    
60.                         myBuf.myClose();//关闭流也就关闭了缓冲
    
61.                         try {
    
62.                                 out.close();//关流
    
63.                         } catch (IOException e) {
    
64.                                 System.out.println(e);
    
65.                         }
    
66.                 }
    
67.                 long end = System.currentTimeMillis();
    
68.                 System.out.println("time" + (end - start)/1000);//复制500多kb竟然用12秒
    
69.         }
    
70. }

复制代码

黑马王建伟 发表于 2012-9-7 16:08
同学，看了你的代码，感觉别扭，你看我的代码，没有try，直接throws的，运行时间的话，很短，你可以复制代 ...

我看了，这样是直接调用FileInputStream的read,所以它会很快，我这个是学习老师那样自己模拟缓冲区也就是模拟BufferedInputStream的实现。谢谢分析，加油。

自己顶哈。

我看了，这样是直接调用FileInputStream的read,所以它会很快，我这个是学习老师那样自己模拟缓冲区也就是模拟BufferedInputStream的实现。谢谢分析，加油。

同学，看了你的代码，感觉别扭，你看我的代码，没有try，直接throws的，运行时间的话，很短，你可以复制代码试下

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class LianXi{
public static void main(String[] args) throws IOException {
  Long start=System.currentTimeMillis();
  FileInputStream fis=new FileInputStream("g:/java/a.mp3");
  FileOutputStream fos=new FileOutputStream("g:/java/b.mp3");
  byte[]b=new byte[1024];
  int num=0;
  while(-1!=(num=fis.read(b))){
   fos.write(b,0,num);
   fos.flush();
  }
  fis.close();
  fos.close();
  Long end=System.currentTimeMillis();
  System.out.println("复制一个文件所有的时间"+(end-start)+"毫秒");
}
}