文件读出和写入两种基本方法

   文件读出和写入两种基本方法

  首先，我们的目的是：通过java源代码的运行将文件从一个地方复制到另外一个地方。只需要两步就可以了——将文件读出来，将读出来的内容保存到新建的一个文件夹内。

  现在介绍两种最基本的方法——字节流InputStream和缓冲流BufferedInputStream。第一种是将磁盘中文件的内容一个一个字节的读出写入；后一种则是将文件一段一段的读出写入。在创建 BufferedInputStream 时，会相应的创建一个内部缓冲区数组在java虚拟机内存中，因此每次处理的就是这一整块内存。

  我们先用InputStream来实现这一功能，然后再用BufferedInputStream 实现，最后比较这两者的优劣。

 

Java代码  

1. <span style="">/** 
2.      * 读取指定文件内容 
3.      *  
4.      * @param fileName被复制文件名 
5.      * @return 将读取到的内容作为String类型返回 
6.      * @throws IOException 
7.      *             文件操作异常 
8.      */  
9.     private String readFileString(String fileName)  
10.             throws IOException {  
11.         // java.io.InputStream抽象类是表示字节输入流的所有类的超类,java.io.FileInputStream是它的一个实现类  
12.         // 定义这样的输入流对象，来进行文件操作  
13.         java.io.InputStream ins = new java.io.FileInputStream(fileName);  
14.         // 也可以这样（多个构造方法）  
15.         // java.io.InputStream ins1 = new java.io.FileInputStream(new  
16.         // File(fileName));  
17.         // 根据ins中的字节长度 创建一个byte数组保存读出的数据  
18.         byte[] contentByte = new byte[ins.available()];  
19.         // 对contentByte数组赋值  
20.         // 读入就是把文件中的东西读出后读入到另一个东西里去  
21.         ins.read(contentByte);  
22.         //方法二  
23. //      while (true) {  
24. //          int i = ins.read();  
25. //          if(i == -1)  
26. //              break;  
27. //    
28. //      }  
29.         // 把contentByte转变为String类型  
30.         String s = new String(contentByte);  
31.         //关闭文件流  
32.         ins.close();  
33.         System.out.println("InputStream使用结束，文件已被读出");  
34.         return s;  
35.     }</span>  

  下一步就是创建一个新的文件，然后将刚刚获得的返回值写入进去便可了。

Java代码  

1. <span style="">/** 
2.      * contentString 文件的内容 
3.      * @param path新路径名  
4.      * @throws IOException 
5.      *             文件操作异常 
6.      */  
7.     private void whiteFile_OutputStream(String contentString， String path)  
8.             throws IOException {  
9.         // 定义输出流对象，来进行文件操作  
10.         java.io.OutputStream os = new java.io.FileOutputStream(path);  
11.         // 对contentByte数组赋值  
12.         byte[] contentByte = contentString.getBytes();  
13.         //写入path中  
14.         os.write(contentByte);  
15.         os.close();  
16.         System.out.println("OutputStream结束，文件已被复制");  
17.     }</span>  

 这样的话filename里面的文件就被复制到了path里面。

     下面我们再看一下如果是BufferedInputStream 会怎么样。

Java代码  

1. <span style="">/** 
2.      * 复制指定文件内容 
3.      * @param path新文件的路径 
4.      * @param fileName 
5.      *  
6.      * @throws IOException 
7.      *             文件操作异常 
8.      */  
9.     private void copyBuffered(String fileName, String path)  
10.             throws IOException {//还是需要先 定义InputStream输入流对象    
11.         java.io.InputStream ins = new java.io.FileInputStream(fileName);  
12.         // 创建一个BufferedInputStream对象时 需要用InputStream作为输入  
13.         java.io.BufferedInputStream bis = new java.io.BufferedInputStream(ins);  
14.         // 文件复制中的输出流  
15.         java.io.OutputStream os = new java.io.FileOutputStream(path);  
16.         java.io.BufferedOutputStream bos = new java.io.BufferedOutputStream(os);  
17.         // 根据ins中的字节长度 创建一个byte数组保存读出的数据  
18.         byte[] contentByte = new byte[bis.available()];  
19.         // 对contentByte数组赋值  
20.         // 读入就是把文件中的东西读出后读入到另一个东西里去  
21.                bis.read(contentByte);  
22.         bos.write(contentByte);  
23. //方法二       while (true) {  
24. //          int i = bis.read();  
25. //          if (i == -1) {  
26. //              break;  
27. //          }  
28. //          bos.write(i);  
29. //      }  
30.         System.out.println("BufferedInputStream拷贝结束");  
31.         bos.flush();// 将缓冲区中的内容强制全部写入到文件中（不管是否已经全部写入）有点类似于下面的语句  
32.         // bos.close();  
33.         // bis.close();  
34.         // os.close();  
35.         // ins.close();  
36.           
37.     }</span>  

 

   读者将会发现其实并没有多少区别。

   只能说，形式的确是如此。但程序运行时内部的处理是不同的，这体现为后者的读取复制速度远远快于前者。

转自： http://java--hhf.iteye.com/blog/1747507