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

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

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

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

 

/**
	 * 读取指定文件内容
	 * 
	 * @param fileName被复制文件名
	 * @return 将读取到的内容作为String类型返回
	 * @throws IOException
	 *             文件操作异常
	 */
	private String readFileString(String fileName)
			throws IOException {
		// java.io.InputStream抽象类是表示字节输入流的所有类的超类,java.io.FileInputStream是它的一个实现类
		// 定义这样的输入流对象，来进行文件操作
		java.io.InputStream ins = new java.io.FileInputStream(fileName);
		// 也可以这样（多个构造方法）
		// java.io.InputStream ins1 = new java.io.FileInputStream(new
		// File(fileName));
		// 根据ins中的字节长度 创建一个byte数组保存读出的数据
		byte[] contentByte = new byte[ins.available()];
		// 对contentByte数组赋值
		// 读入就是把文件中的东西读出后读入到另一个东西里去
		ins.read(contentByte);
		//方法二
//		while (true) {
//			int i = ins.read();
//			if(i == -1)
//				break;
//	
//		}
		// 把contentByte转变为String类型
		String s = new String(contentByte);
		//关闭文件流
		ins.close();
		System.out.println("InputStream使用结束，文件已被读出");
		return s;
	}

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

/**
	 * contentString 文件的内容
	 * @param path新路径名 
	 * @throws IOException
	 *             文件操作异常
	 */
	private void whiteFile_OutputStream(String contentString， String path)
			throws IOException {
		// 定义输出流对象，来进行文件操作
		java.io.OutputStream os = new java.io.FileOutputStream(path);
		// 对contentByte数组赋值
		byte[] contentByte = contentString.getBytes();
		//写入path中
		os.write(contentByte);
		os.close();
		System.out.println("OutputStream结束，文件已被复制");
	}

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

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

/**
	 * 复制指定文件内容
	 * @param path新文件的路径
	 * @param fileName
	 * 
	 * @throws IOException
	 *             文件操作异常
	 */
	private void copyBuffered(String fileName, String path)
			throws IOException {//还是需要先 定义InputStream输入流对象	
		java.io.InputStream ins = new java.io.FileInputStream(fileName);
		// 创建一个BufferedInputStream对象时 需要用InputStream作为输入
		java.io.BufferedInputStream bis = new java.io.BufferedInputStream(ins);
		// 文件复制中的输出流
		java.io.OutputStream os = new java.io.FileOutputStream(path);
		java.io.BufferedOutputStream bos = new java.io.BufferedOutputStream(os);
		// 根据ins中的字节长度 创建一个byte数组保存读出的数据
		byte[] contentByte = new byte[bis.available()];
		// 对contentByte数组赋值
		// 读入就是把文件中的东西读出后读入到另一个东西里去
	           bis.read(contentByte);
		bos.write(contentByte);
//方法二		while (true) {
//			int i = bis.read();
//			if (i == -1) {
//				break;
//			}
//			bos.write(i);
//		}
		System.out.println("BufferedInputStream拷贝结束");
		bos.flush();// 将缓冲区中的内容强制全部写入到文件中（不管是否已经全部写入）有点类似于下面的语句
		// bos.close();
		// bis.close();
		// os.close();
		// ins.close();
		
	}

 

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

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

 

评论

8 楼 canghailan 2012-12-17  

yonge812 写道

canghailan 写道

FileChannel.transferTo

，其实这个更方便，性能可能更好。

http://yonge812.iteye.com/blog/1747393这是我做的测试，并没有体现他的高性能。

性能可能更好更多地体现在CPU与内存使用上。
传统拷贝方式：源文件块=>操作系统文件缓存=>JVM缓冲区=>操作系统文件缓存=>目标文件块。
而NIO省掉了 操作系统文件缓存=>JVM缓冲区=>操作系统文件缓存 这个过程。
对于常规的磁盘IO来说，内存中内容拷贝所消耗的时间可以忽略。
操作系统可能会使用DMA等来节省系统资源，所以transferTo可能性能（CPU，内存）更好，但也要看具体实现。
测试第一次比其他几次耗时长应该是操作系统文件缓存的原因。

7 楼 sc_zcx 2012-12-15  

学习了。。。。

6 楼 java--hhf 2012-12-14  

byte[] contentByte = new byte[1024];
OutputStream os = new FileOutputStream("fileName");
while(true){
   int ret = bis.read(contentByte);
   if (ret > 0) {
	os.write(buf, 0, ret);
   } else if (-1 == ret) {
	break;
   }
}
os.close();  

这个代码写的不错^_^ 谢谢啦

5 楼 java--hhf 2012-12-14  

FileChannel.transferTo  这个 具体咋用呢？？ API貌似不好懂

4 楼 yonge812 2012-12-14  

canghailan 写道

FileChannel.transferTo

，其实这个更方便，性能可能更好。

http://yonge812.iteye.com/blog/1747393这是我做的测试，并没有体现他的高性能。

3 楼 xiaoZ5919 2012-12-14  

crazywen2011 写道

byte[] contentByte = new byte[bis.available()];  
        // 对contentByte数组赋值  
        // 读入就是把文件中的东西读出后读入到另一个东西里去  
               bis.read(contentByte);  
        bos.write(contentByte);  
//方法二       while (true) {  
//          int i = bis.read();  
//          if (i == -1) {  
//              break;  
//          }  
//          bos.write(i);  
//      }  

对于这种做法并不赞成，小文件还可以用用，文件很大的话，会造成内存溢出的哦。

byte[] contentByte = new byte[1024];
OutputStream os = new FileOutputStream("fileName");
while(true){
   int ret = bis.read(contentByte);
   if (ret > 0) {
	os.write(buf, 0, ret);
   } else if (-1 == ret) {
	break;
   }
}
os.close();  

个人更赞成这样的写法

还是1楼说的fileChannel.transferTo吧其实两个文件的读写，没有必要字节数组copy到jvm的内存中。利用fileChannel在内核态搞定避免了四次copy

2 楼 crazywen2011 2012-12-14  

byte[] contentByte = new byte[bis.available()];  
        // 对contentByte数组赋值  
        // 读入就是把文件中的东西读出后读入到另一个东西里去  
               bis.read(contentByte);  
        bos.write(contentByte);  
//方法二       while (true) {  
//          int i = bis.read();  
//          if (i == -1) {  
//              break;  
//          }  
//          bos.write(i);  
//      }  

对于这种做法并不赞成，小文件还可以用用，文件很大的话，会造成内存溢出的哦。

byte[] contentByte = new byte[1024];
OutputStream os = new FileOutputStream("fileName");
while(true){
   int ret = bis.read(contentByte);
   if (ret > 0) {
	os.write(buf, 0, ret);
   } else if (-1 == ret) {
	break;
   }
}
os.close();  

个人更赞成这样的写法

1 楼 canghailan 2012-12-14  

FileChannel.transferTo

，其实这个更方便，性能可能更好。