rosial

lost memory
数据加载中……

zz - Java 流（Stream）简介：1、基本的输入流和输出流

原作者为csdn上的 YidingHehttp://blog.csdn.net/YidingHe

本人打算写几篇文章，介绍一下流。本文是针对初学者的，加上本人水平有限，所以不敢说写得很高深。如果你是初学者，而且对流这个东西很头疼，你就应该看看这个。

 

本文发表在：http://blog.csdn.net/YidingHe，转载请保留出处。

 

 

 

流是 Java 中最重要的基本概念之一。文件读写、网络收发、进程通信，几乎所有需要输入输出的地方，都要用到流。

流是做什么用的呢？就是做输入输出用的。为什么输入输出要用“流”这种方式呢？因为程序输入输出的基本单位是字节，输入就是获取一串字节，输出就是发送一串字节。但是很多情况下，程序不可能接收所有的字节之后再进行处理，而是接收一点处理一点。比方你下载魔兽世界，不可能全部下载到内存里再保存到硬盘上，而是下载一点就保存一点。这时，流这种方式就非常适合。

在 Java 中，每个流都是一个对象。流分为两种：输入流(InputStream)和输出流(OutputStream)。对于输入流，你只要从流当中不停地把字节取出来就是了；而对于输出流，你只要把准备好的字节串传给它就行。

          ______________Java 程序____________
          |                                 |
外部系统 --|--(输入流)--> 处理逻辑 --(输出流)---|--> 外部系统
          |_________________________________|


流对象是怎么获得的呢？不同的外部系统，获取流的方式也不同。例如，文件读写就要创建 FileInputStream/FileOutputStream 对象，而网络通信是通过 Socket 对象来获取输入输出流的。一般来说，如果一个类有 getInputStream() 或 getOutputStream() 这样的方法，就表明它是通过流对象来进行输入输出的。

 

InputStream 是输入流，下面是一个通过 InputStream 读取文件的例子：

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.FileNotFoundException;  
  6. import java.util.Arrays;  
  7.    
  8. /** 
  9.  * 通过流读取文件 
  10.  */  
  11. public class ReadFileDemo {  
  12.    
  13.     // 程序入口  
  14.     public static void main(String[] args) {  
  15.         String path = "c:/boot.ini";  
  16.         File file = new File(path);  
  17.    
  18.         // 创建输入流  
  19.         InputStream is;  
  20.         try {  
  21.             is = new FileInputStream(file);  
  22.         } catch (FileNotFoundException e) {  
  23.             System.err.println("文件 " + path + " 不存在。");  
  24.             return;  
  25.         }  
  26.    
  27.         // 开始读取  
  28.         byte[] content = new byte[0];       // 保存读取出来的文件内容  
  29.         byte[] buffer = new byte[10240];    // 定义缓存  
  30.    
  31.         try {  
  32.             int eachTime = is.read(buffer); // 第一次读取。如果返回值为 -1 就表示没有内容可读了。  
  33.             while (eachTime != -1) {  
  34.                 // 读取出来的内容放在 buffer 中，现在将其合并到 content。  
  35.                 content = concatByteArrays(content, buffer, eachTime);  
  36.                 eachTime = is.read(buffer); // 继续读取  
  37.             }  
  38.         } catch (IOException e) {  
  39.             System.err.println("读取文件内容失败。");  
  40.             e.printStackTrace();  
  41.         } finally {  
  42.             try {  
  43.                 is.close();  
  44.             } catch (IOException e) {  
  45.                 // 这里的异常可以忽略不处理  
  46.             }  
  47.         }  
  48.    
  49.         // 输出文件内容  
  50.         String contentStr = new String(content);  
  51.         System.out.println(contentStr);  
  52.     }  
  53.    
  54.     /** 
  55.      * 合并两个字节串 
  56.      * 
  57.      * @param bytes1       字节串1 
  58.      * @param bytes2       字节串2 
  59.      * @param sizeOfBytes2 需要从 bytes2 中取出的长度 
  60.      * 
  61.      * @return bytes1 和 bytes2 中的前 sizeOfBytes2 个字节合并后的结果 
  62.      */  
  63.     private static byte[] concatByteArrays(byte[] bytes1, byte[] bytes2, int sizeOfBytes2) {  
  64.         byte[] result = Arrays.copyOf(bytes1, (bytes1.length + sizeOfBytes2));  
  65.         System.arraycopy(bytes2, 0, result, bytes1.length, sizeOfBytes2);  
  66.         return result;  
  67.     }  
  68. }  

 

 

虽然写得很啰嗦，但这确实是 InputStream 的基本用法。注意，这只是一个例子，说明如何从输入流中读取字节串。实际上，Java 提供更简单的方式来读取文本文件。以后将会介绍。

相比从流中读取，使用 OutputStream 输出则是非常简单的事情。下面是一个例子：

  1. import java.io.OutputStream;  
  2. import java.io.FileOutputStream;  
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.util.Date;  
  6.    
  7. /** 
  8.  * 将当前日期保存到文件 
  9.  */  
  10. public class SaveFileDemo {  
  11.    
  12.     public static void main(String[] args) throws IOException {  
  13.         String path = "c:/now.txt";  
  14.    
  15.         File file = new File(path);  
  16.         if (!file.exists() && !file.createNewFile()) {  
  17.             System.err.println("无法创建文件。");  
  18.             return;  
  19.         }  
  20.    
  21.         OutputStream os = new FileOutputStream(file);   // 创建输出流（前提是文件存在）  
  22.         os.write(new Date().toString().getBytes());     // 将当前时间写入文件  
  23.         os.close();                                     // 必须关闭流，内容才会写入文件。  
  24.         System.out.println("文件写入完成。");  
  25.     }  
  26. }  

 

Java 还提供其它的流操作方式，但它们都是对 InputStream 和 OutputStream 进行扩展或包装。所以这两个类是基础，必须要理解它们的使用。

 

 

posted on 2012-03-02 20:20 rosial 阅读(266) 评论(0)  编辑  收藏 所属分类: 技术转帖留存


只有注册用户登录后才能发表评论。
网站导航: