Java中的字节流，字符流，字节缓冲区，字符缓冲区复制文件

一：创建方式

1、建立输入（读）对象，并绑定数据源

2、建立输出（写）对象，并绑定目的地

3、将读到的内容遍历出来，然后在通过字符或者字节写入

4、资源访问过后关闭，先创建的后关闭，后创建的先关闭

总结：创建的方式都是差不多的，只不过是使用的输入和输出流不一样。

二：四种流复制文件的例子：

1、字节流复制文件

 1 //1、字节流复制文件
 2     public static void fun(File src,File desc ) throws Exception{
 3         //建立字节流输入（读）对象，并绑定数据源
 4         FileInputStream fis = new FileInputStream(src);
 5         //建立字节流输出（写）对象，并绑定目的地
 6         FileOutputStream fos=new FileOutputStream(desc);
 7         int len=0;
 8         byte[] b=new byte[1024];
 9         //将读到的内容遍历出来，然后在通过字节写入
10         while((len=fis.read(b))!=-1){
11             fos.write(b,0,len);
12         }
13         //资源访问过后关闭，先创建的后关闭，后创建的先关闭
14         fos.close();
15         fis.close();
16     }

2、字符流复制文件

 1 //2、字符流复制文件
 2     public static void fun1(File src,File desc) throws Exception{
 3         //建立字符流输入（读）对象，并绑定数据源
 4         FileReader fReader=new FileReader(src);
 5         //建立字符流输出（写）对象，并绑定目的地
 6         FileWriter fWriter=new FileWriter(desc);
 7         int len=0;
 8         char[] b=new char[1024];
 9         //遍历出需复制的文件的字节，一个字符一个字符的写入复制过后的新文件中
10         while((len=fReader.read(b))!=-1){
11             fWriter.write(b,0,len);
12         }
13         //资源访问过后关闭，先创建的后关闭，后创建的先关闭
14         fWriter.close();
15         fReader.close();
16     }

3、字节缓冲区复制文件

 1 //3、字节缓冲区复制文件
 2     public static void fun2(File src,File desc) throws Exception{
 3         //建立字节缓冲流输入（读）对象，并绑定数据源
 4         BufferedInputStream bu=new BufferedInputStream(new FileInputStream(src));
 5         //建立字节缓冲流输出（写）对象，并绑定目的地
 6         BufferedOutputStream ou=new BufferedOutputStream(new FileOutputStream(desc));
 7         int len=0;
 8         byte[] by=new byte[1024];
 9         //将读到的内容遍历出来，然后在通过字节写入
10         while((len=bu.read(by))!=-1){
11             ou.write(by,0,len);
12         }
13         //资源访问过后关闭，先创建的后关闭，后创建的先关闭
14         ou.close();
15         bu.close();
16     }

4、字符缓冲区复制文件

 1 //4、字符缓冲区复制文件
 2     public static void fun3(File src,File desc) throws Exception{
 3         //建立字符缓冲流输入（读）对象，并绑定数据源
 4         BufferedReader br=new BufferedReader(new FileReader(src));
 5         //建立字符缓冲流输出（写）对象，并绑定目的地
 6         BufferedWriter bw=new BufferedWriter(new FileWriter(desc));
 7         String len="";
 8         char[] c=new char[1024];
 9         //将读到的内容遍历出来，然后在通过字符写入
10         while((len=br.readLine())!=null){
11             bw.write(c,0,len.length());
12         }
13         //资源访问过后关闭，先创建的后关闭，后创建的先关闭
14         bw.close();
15         br.close();
16     }

调用方法：

方法名(参数1，参数2）；

其中我的参数1写的是读的对象也就是数据源，参数2代表的是要写入的目的地

1 fun(new File("c:\bu.txt"),new File("d:\kk.txt"));