求教！使用带缓冲功能的字节流复制文件怎么复制？  没接触过流。

这个其实很简单的哦, 所谓的缓冲就是一次读取的数据多一点, 不用每次只读取一个字节

举个简单的例子
你要吃花生米, 如果你用筷子夹的话, 正常情况下一次是不是只能夹一粒花生米, 如果你用勺子呢?
是不是每次就可以吃到很多的花生米呢, 缓冲区用的就是这个道理, 可以提高效率的哦, 你想想吃花生米的那个例子觉得是不是呢?

1. import java.io.BufferedInputStream;
   
2. import java.io.BufferedOutputStream;
   
3. import java.io.FileInputStream;
   
4. import java.io.FileOutputStream;
   
5. import java.io.IOException;
   
6. 
   
7. public class SunJingQi {
   
8.         public static void main(String[] args) {
   
9. 
   
10.                 BufferedInputStream bufis = null;
    
11.                 BufferedOutputStream bufos = null;
    
12. 
    
13.                 try {
    
14.                         bufis = new BufferedInputStream(new FileInputStream(
    
15.                                         "c:\\sunjingqi.mp3"));
    
16.                         bufos = new BufferedOutputStream(new FileOutputStream(
    
17.                                         "f:\\sunjingqi.mp3"));
    
18. 
    
19.                         int byt = 0;
    
20.                         while ((byt = bufis.read()) != -1) {
    
21.                                 bufos.write(byt);
    
22.                         }
    
23.                 } catch (IOException e) {
    
24.                         throw new RuntimeException("MP3拷贝失败");
    
25.                 } finally {
    
26.                         try {
    
27.                                 if (bufis != null)
    
28.                                         bufis.close();
    
29.                         } catch (IOException e) {
    
30.                                 throw new RuntimeException("读取关闭失败");
    
31.                         }
    
32.                         try {
    
33.                                 if (bufos != null)
    
34.                                         bufos.close();
    
35.                         } catch (IOException e) {
    
36.                                 throw new RuntimeException("写入关闭失败");
    
37.                         }
    
38.                 }
    
39.         }
    
40. }
    

复制代码

你可以对比这个没有使用缓冲区的代码, 看看有什么不一样, 很简单的哦

1. import java.io.FileInputStream;
   
2. import java.io.FileOutputStream;
   
3. import java.io.IOException;
   
4. 
   
5. public class SunJingQi {
   
6. 
   
7.         public static void main(String[] args) {
   
8. 
   
9.                 FileInputStream fis = null;
   
10.                 FileOutputStream fos = null;
    
11. 
    
12.                 try {
    
13.                         fis = new FileInputStream("c:\\sunjingqi.jpg");
    
14.                         fos = new FileOutputStream("F:\\sunjingqi.jpg");
    
15. 
    
16.                         byte[] buf = new byte[1024];
    
17.                         int len = 0;
    
18.                         while ((len = fis.read(buf)) != -1) {
    
19.                                 fos.write(buf, 0, len);
    
20.                         }
    
21. 
    
22.                 } catch (IOException e) {
    
23.                         throw new RuntimeException("图片拷贝失败");
    
24.                 } finally {
    
25.                         try {
    
26.                                 if (fis != null)
    
27.                                         fis.close();
    
28.                         } catch (IOException e) {
    
29.                                 throw new RuntimeException("读取关闭失败");
    
30.                         }
    
31.                         try {
    
32.                                 if (fos != null)
    
33.                                         fos.close();
    
34.                         } catch (IOException e) {
    
35.                                 throw new RuntimeException("写入关闭失败");
    
36.                         }
    
37.                 }
    
38.         }
    
39. }
    

复制代码

import java.io.*;

class Demo33{

public static void main(String[] args) throws IOException{

  //简化写法，建立BufferdReader和BufferedWriter两个缓冲
  BufferedReader bufr=new BufferedReader(new InputStreamReader(new FileInputStream("c:\\k1.txt")));
  BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d:\\k2.txt")));
  String line=null;

  //读取k1中的内容
  while((line=bufr.readLine())!=null){
  //写到k2中
   bufw.write(line);

  //换行
   bufw.newLine();

  //刷新
   bufw.flush();
  }

  //关流
  bufw.close();
  bufr.close();
}
}


这其中用到了转换流InputStreamReader和OutputStreamWriter，字节流FileInputStream和FileOutputStream。

1. import java.io.*;
   
2. class Copy
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 copy();
   
7.         }
   
8.         public static void copy()
   
9.         {
   
10.                 BufferedInputStream bis = null;
    
11.                 BufferedOutputStream bos = null;
    
12.                 File file1 = new File("D:\\a.jpg");
    
13.                 File file2 = new File("D:\\b.jpg");
    
14.                 try
    
15.                 {
    
16.                         bis = new BufferedInputStream(new FileInputStream(file1));
    
17.                         bos = new BufferedOutputStream(new FileOutputStream(file2));
    
18.                         int num = 0;
    
19.                         byte[] buf = new byte[1024];
    
20.                         while ((num = bis.read(buf)) != -1)
    
21.                         {
    
22.                                 bos.write(buf);
    
23.                         }
    
24.                 }
    
25.                 catch (IOException e)
    
26.                 {
    
27.                         throw new RuntimeException("复制失败");
    
28.                 }
    
29.                 finally
    
30.                 {
    
31.                         try
    
32.                         {
    
33.                                 if( bis != null)
    
34.                                         bis.close();
    
35.                         }
    
36.                         catch (IOException e)
    
37.                         {
    
38.                                 throw new RuntimeException(e);
    
39.                         }
    
40.                         try
    
41.                         {
    
42.                                 if( bos != null)
    
43.                                         bos.close();
    
44.                         }
    
45.                         catch (IOException e)
    
46.                         {
    
47.                                 throw new RuntimeException(e);
    
48.                         }
    
49.                 }
    
50.        
    
51.         }
    
52. }
    

复制代码

来男. 发表于 2014-5-2 16:53
import java.io.*;

class Demo33{

挺好，我刚学到流，挺简洁的

坏男孩 发表于 2014-5-3 10:52
挺好，我刚学到流，挺简洁的

同学，你之前说的复制文件是文本、照片还是mp3呀？

来男. 发表于 2014-5-3 11:14
同学，你之前说的复制文件是文本、照片还是mp3呀？

文本，这是黑马基础测试的一道题，我之前没接触过流

碰到同样的问题，谁测试 做过了？

大神无处不在啊~~~

孙旌棋 发表于 2014-5-2 16:49
这个其实很简单的哦, 所谓的缓冲就是一次读取的数据多一点, 不用每次只读取一个字节

举个简单的例子

如何将你所要复制的文件路径与代码文件的路径相关联

这个太赞了

这个太赞了

孙旌棋 发表于 2014-5-2 16:49
这个其实很简单的哦, 所谓的缓冲就是一次读取的数据多一点, 不用每次只读取一个字节

举个简单的例子

这个如果不使用缓冲区也是一样的吗？

大学学的东西全忘了，现在一点一点捡

用到了转换流InputStreamReader和OutputStreamWriter，字节流FileInputStream和FileOutputStream。

赞一个!刚好今天碰到了，，嘿嘿~~~

还是看不懂啊。。。。。

这个要多看看   我还不怎么懂

分享快乐 赞一个