自己写了个字节流缓冲区，复制歌曲，结果出现了死循环，不知道问题出在哪了…………

1. /*
   
2.         自定义一个字节流缓冲区
   
3. */
   
4. 
   
5. import java.io.IOException;
   
6. import java.io.InputStream;
   
7. import java.io.FileInputStream;
   
8. import java.io.FileOutputStream;
   
9. 
   
10. 
    
11. class MyBufferedInputStream
    
12. {
    
13.         private InputStream is;
    
14.         int pos=0,count=0;
    
15.         byte[] bufb = new byte[1024];
    
16. 
    
17.         MyBufferedInputStream(InputStream is)
    
18.         {
    
19.                 this.is = is;
    
20.         }
    
21. 
    
22.         public int myRead() throws IOException
    
23.         {
    
24.                 //当count==0时，需从硬盘中取数据到缓冲区(即bufb中)。
    
25.                 if(count==0)
    
26.                 {
    
27.                         count = is.read(bufb);
    
28.                         System.out.println("if1 count = "+count);
    
29.                         if(count<0)//当count<0，说明硬盘中已无数据，不必读取，故返回-1
    
30.                                 return -1;
    
31.                         pos = 0;//每重新装载一次缓冲区，需将pos置0
    
32.                 }
    
33. 
    
34.                 //当count>0时，需读取缓冲区的数据
    
35.                 if(count>0)
    
36.                 {
    
37.                         byte b = bufb[pos++];
    
38.                         count--;
    
39.                         System.out.println("if2 count = "+count);
    
40.                         return b&255;//        先将b由byte转为int,然后保留低8位，高位置0               
    
41.                 }
    
42. 
    
43.                 return -1;//?????????????
    
44.         }
    
45. 
    
46.         public void close() throws IOException
    
47.         {
    
48.                 is.close();
    
49.         }
    
50. }
    
51. 
    
52. 
    
53. class MyBufferedInputStreamDemo
    
54. {
    
55.         public static void main(String[] args) throws IOException
    
56.         {
    
57.                 long start = System.currentTimeMillis();
    
58.                 copy();
    
59.                 long end = System.currentTimeMillis();
    
60.                 System.out.println("time = "+(end-start));
    
61.         }
    
62. 
    
63.         //复制歌曲
    
64.         public static void copy() throws IOException
    
65.         {
    
66.                 MyBufferedInputStream mbis = null;
    
67.                 FileOutputStream fos = null;
    
68.                 try
    
69.                 {
    
70.                         mbis = new MyBufferedInputStream(new FileInputStream("d:\\G.E.M. 邓紫棋 - 后会无期.mp3"));
    
71.                         fos = new FileOutputStream("f:\\邓紫棋.mp3");
    
72.                         int b;
    
73.                         while((b=mbis.myRead())!=-1)
    
74.                         {
    
75.                                 fos.write(b);
    
76.                         }
    
77.                 }
    
78.                 catch (IOException e)
    
79.                 {
    
80.                         throw new IOException("读写异常");
    
81.                 }
    
82.                 finally
    
83.                 {
    
84.                         if(mbis!=null)
    
85.                                 try
    
86.                                 {
    
87.                                         mbis.close();
    
88.                                 }
    
89.                                 catch (IOException e)
    
90.                                 {
    
91.                                         throw new IOException("读资源关闭异常");
    
92.                                 }
    
93.                         if(fos!=null)
    
94.                                 try
    
95.                                 {
    
96.                                         fos.close();
    
97.                                 }
    
98.                                 catch (IOException e)
    
99.                                 {
    
100.                                         throw new IOException("写资源关闭异常");
     
101.                                 }
     
102.                 }
     
103.         }
     
104. }
     

复制代码

小黑子 发表于 2014-9-23 15:15
非常感谢。但是你这个写的是和毕老师的差不多的。
我现在就是想知道我的代码哪里错了。是我的代码在逻辑 ...

你的代码没有错。输出流选的类导致效率低

Huberry 发表于 2014-9-23 10:39
程序是没有死循环的，是你这程序效率实在是太慢，在我电脑上复制10K的数据就要2秒，你复制一首3M的MP3文件 ...

果然是运行效率低，谢谢啦~~

careit 发表于 2014-9-23 10:55
修改的直接写在注释里面了

非常感谢。但是你这个写的是和毕老师的差不多的。
我现在就是想知道我的代码哪里错了。是我的代码在逻辑结构是有问题么？
我设想的是，为了避免代码重复，所以在第1个if中只将数据读取到缓冲区，在第2个中再从缓冲区存储到文件中。难道这样设计会丢失第一个数据？

修改的直接写在注释里面了

1. package test;
   
2. 
   
3. import java.io.BufferedOutputStream;
   
4. import java.io.FileInputStream;
   
5. import java.io.FileOutputStream;
   
6. 
   
7. /*
   
8. 自定义一个字节流缓冲区
   
9. */
   
10. import java.io.IOException;
    
11. import java.io.InputStream;
    
12. 
    
13. class MyBufferedInputStream {
    
14.         private InputStream is;
    
15.         int pos = 0;
    
16.         int count = 0;
    
17.         byte[] bufb = new byte[1024];
    
18. 
    
19.         MyBufferedInputStream(InputStream is) {
    
20.                 this.is = is;
    
21.         }
    
22. 
    
23.         public int read() throws IOException {
    
24.                 // 当count==0时，需从硬盘中取数据到缓冲区(即bufb中)。
    
25.                 if (count == 0) {
    
26.                         count = is.read(bufb);
    
27.                         // System.out.println("if1 count = " + count);
    
28.                         if (count < 0) { // 当count<0，说明硬盘中已无数据，不必读取，故返回-1
    
29.                                 return -1;
    
30.                         }
    
31.                         pos = 0; // 每重新装载一次缓冲区，需将pos置0
    
32.                         count--;// 重新一次读到数据、自然返回第一个啊
    
33.                         return bufb[pos] & 255;
    
34.                 }
    
35.                 else{
    
36.                 // 当count>0时，需读取缓冲区的数据
    
37.                 if (count > 0) {
    
38.                         // 先把pos 自加一次，在取值。不然还是0.毕老师是在上面pos++
    
39.                         byte b = bufb[++pos];// 改为byte b = bufb[++pos]
    
40.                         count--;
    
41.                         // System.out.println("if2 count = " + count);
    
42.                         return b & 255; // 先将b由byte转为int,然后保留低8位，高位置0
    
43.                 }
    
44.                 }
    
45.                 return -1; // ?????????????这里是逻辑上不会被执行到的，为了语法正确
    
46.         }
    
47. 
    
48.         public void close() throws IOException {
    
49.                 is.close();
    
50.         }
    
51. }
    
52. 
    
53. public class MyBufferedInputStreamDemo {
    
54.         public static void main(String[] args) throws IOException {
    
55.                 long start = System.currentTimeMillis();
    
56.                 copy();
    
57. 
    
58.                 long end = System.currentTimeMillis();
    
59.                 System.out.println("time = " + (end - start));
    
60.         }
    
61. 
    
62.         // 复制歌曲
    
63.         public static void copy() throws IOException {
    
64.                 MyBufferedInputStream mbis = null;
    
65.                 FileOutputStream fos = null;
    
66. //                BufferedOutputStream fos=null;
    
67.                 try {
    
68.                         // mbis = new MyBufferedInputStream(new FileInputStream(
    
69.                         // "d:\\G.E.M. 邓紫棋 - 后会无期.mp3"));
    
70.                         // fos = new FileOutputStream("f:\\邓紫棋.mp3");
    
71. 
    
72.                         mbis = new MyBufferedInputStream(new FileInputStream("f:\\1.mp3"));
    
73.                         fos = new FileOutputStream("f:\\2.mp3");
    
74. //                        fos=new BufferedOutputStream(new FileOutputStream("f:\\2.mp3") );
    
75.                        
    
76.                         //复制完MP3 之后一定要查看一下文件大小。看字节，最好在复制一次图片
    
77.                         //测试时发现，mp3 错误了一点也可以播放，你可以把bufb[++pos];改为 bufb[pos++]
    
78.                         //文件大小一样，MP3可以播放，但声音失真了。复制图片直接打不开
    
79. //                        mbis = new MyBufferedInputStream(new FileInputStream("f:\\fis.jpg"));
    
80. //                        fos = new FileOutputStream("f:\\fos.jpg");
    
81. //                        fos=new BufferedOutputStream(new FileOutputStream("f:\\2.mp3") );
    
82.                        
    
83.                         int b;
    
84. 
    
85.                         while ((b = mbis.read())!=-1) {
    
86.                                 fos.write(b);
    
87.                         }
    
88.                 } catch (IOException e) {
    
89.                         throw new IOException("读写异常");
    
90.                 } finally {
    
91.                         if (mbis != null) {
    
92.                                 try {
    
93.                                         mbis.close();
    
94.                                 } catch (IOException e) {
    
95.                                         throw new IOException("读资源关闭异常");
    
96.                                 }
    
97.                         }
    
98. 
    
99.                         if (fos != null) {
    
100.                                 try {
     
101.                                         fos.close();
     
102.                                 } catch (IOException e) {
     
103.                                         throw new IOException("写资源关闭异常");
     
104.                                 }
     
105.                         }
     
106.                 }
     
107.         }
     
108. }
     

复制代码

程序是没有死循环的，是你这程序效率实在是太慢，在我电脑上复制10K的数据就要2秒，你复制一首3M的MP3文件就需要10分钟，所以你以为是死循环

你这定义的字节流缓冲区还不如没有的好， 你这个缓冲区虽然说把从源读来的数据缓存了，但是往目标文件写的时候效率非常低，每写一个字节，就需要判断count的条件，判断语句是非常影响效率的。而最拖垮你代码效率的是你那两条打印语句，你这每写一个字节就需要执行一次打印“if2“，并且每读1K的数据就要执行一次打印“if1”. 你把打印语句去掉，10几秒应该可以复制完一首歌，你可以看到程序结束，至于自定义字节流缓冲区我建议你再看看视频，琢磨琢磨吧。

大神在哪里？求指导****

苏乞儿 发表于 2014-9-23 00:02
应该是定义的MyRead （）方法的问题，读文件怎么没用循环，只用了if？而且count>0的情况能不能被执行还是个 ...

循环在调用MyRead时用的，而且count>0肯定可以执行到。

fantacyleo 发表于 2014-9-23 00:25
程序正常结束～～

你的确实可以正常结束么？我刚又运行了一下，还是死循环:'(

程序正常结束～～

应该是定义的MyRead （）方法的问题，读文件怎么没用循环，只用了if？而且count>0的情况能不能被执行还是个问题。。。。