Java的I/O系统中的输入输出流为我们进行开发提供了很多便利,利用其强大的封装性,通过各种组合能够实现多种多样的功能。但是Java提供了很多输入输出流类,在概念和使用上有很多相似之处,所以给很多开发者带来了困扰,何时应该用何种输入输出流类成为一个问题。

       以下即是Java输入输出流类的介绍,并附有实例说明,对各个类的用法都有简要分析。

       输入输出流类介绍

      1.stream代表的是任何有能力产出数据的数据源,或是任何有能力接收数据的接收源。在Java的IO中,所有的stream(包括Input和Out   stream)都包括两种类型: 以字节为导向的stream和以Unicode字符为导向的stream。

       1.1 以字节为导向的stream 

       以字节为导向的stream,表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型: 

       input stream: 

       1)   ByteArrayInputStream:把内存中的一个缓冲区作为InputStream使用
       2)   StringBufferInputStream:把一个String对象作为InputStream
       3)   FileInputStream:把一个文件作为InputStream,实现对文件的读取操作
       4)   PipedInputStream:实现了pipe的概念,主要在线程中使用
       5)   SequenceInputStream:把多个InputStream合并为一个InputStream 

       Out stream:

       1)   ByteArrayOutputStream:把信息存入内存中的一个缓冲区中
       2)   FileOutputStream:把信息存入文件中
       3)   PipedOutputStream:实现了pipe的概念,主要在线程中使用
       4)   SequenceOutputStream:把多个OutStream合并为一个OutStream 

       1.2 以Unicode字符为导向的stream 

       以Unicode字符为导向的stream,表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型: 

       Input Stream:

       1)   CharArrayReader:与ByteArrayInputStream对应
       2)   StringReader:与StringBufferInputStream对应
       3)   FileReader:与FileInputStream对应
       4)   PipedReader:与PipedInputStream对应 

       Out Stream:

       1)   CharArrayWrite:与ByteArrayOutputStream对应
       2)   StringWrite:无与之对应的以字节为导向的stream
       3)   FileWrite:与FileOutputStream对应
       4)   PipedWrite:与PipedOutputStream对应 

       以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同,字是在操作时的导向不同。如CharArrayReader:和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用,所不同的是前者每次从内存中读取一个字节的信息,而后者每次从内存中读取一个字符。

       1.3 两种不现导向的stream之间的转换 

       InputStreamReader和OutputStreamReader:把一个以字节为导向的stream转换成一个以字符为导向的stream。 

       2.为stream添加属性 

       2.1 "为stream添加属性”的作用 

       运用上面介绍的Java中操作IO的API,我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类,我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。 如果我们要往一个文件中写入数据,我们可以这样操作: 

       FileOutStream   fs   =   new   FileOutStream(“test.txt”); 

       然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是,如果我们想实现“先把要写入文件的数据先缓存到内存中,再把缓存中的数据写入文件中”的功能时,上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和FilterOutStream的子类,为FileOutStream添加我们所需要的功能。 

       2.2   FilterInputStream的各种类型 

       2.2.1   用于封装以字节为导向的InputStream 

       1)   DataInputStream:从stream中读取基本类型(int、char等)数据。
       2)   BufferedInputStream:使用缓冲区
       3)   LineNumberInputStream:会记录input   stream内的行数,然后可以调用getLineNumber()和setLineNumber(int)
       4)   PushbackInputStream:很少用到,一般用于编译器开发

       2.2.2   用于封装以字符为导向的InputStream 

       1)   没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader,否则使用DataInputStream
       2)   BufferedReader:与BufferedInputStream对应
       3)   LineNumberReader:与LineNumberInputStream对应
       4)   PushBackReader:与PushbackInputStream对应

       2.3   FilterOutStream的各种类型 

       2.2.3   用于封装以字节为导向的OutputStream 

       1)   DataOutputStream:往stream中输出基本类型(int、char等)数据。
       2)   BufferedOutStream:使用缓冲区
       3)   PrintStream:产生格式化输出 

       2.2.4   用于封装以字符为导向的OutputStream 

       1)   BufferedWrite:与BufferedOutStream对应 
       2)   PrintWrite:与PrintStream对应 

       3.   RandomAccessFile 

       1)   可通过RandomAccessFile对象完成对文件的读写操作
       2)   在产生一个对象时,可指明要打开的文件的性质:r,只读;w,只写;rw可读写
       3)   可以直接跳到文件中指定的位置 

       输入输出流应用实例

      下面在main函数中给出6个代码段,说明各个输入输出流类的使用方法,并在代码段后有相应注释说明。

Java代码
  1. import   java.io.*;    
  2. public   class   TestIO{    
  3. public   static   void   main(String[]   args)    
  4. throws   IOException{    
  5.   
  6. //1.以行为单位从一个文件读取数据    
  7. BufferedReader   in   =      
  8. new   BufferedReader(    
  9. new   FileReader( "F:\\nepalon\\TestIO.java "));    
  10. String   s,   s2   =   new   String();    
  11. while((s   =   in.readLine())   !=   null)    
  12. s2   +=   s   +   "\n ";    
  13. in.close();    
  14. // 当读取文件时,先把文件内容读到缓存中,当调用in.readLine()时,再从缓存中以字符的方式读取数据(以下简称“缓存字节读取方式”)。   
  15.   
  16. //1b.   接收键盘的输入    
  17. BufferedReader   stdin   =      
  18. new   BufferedReader(    
  19. new   InputStreamReader(System.in));    
  20. System.out.println( "Enter   a   line: ");    
  21. System.out.println(stdin.readLine());    
  22. // 由于想以缓存字节读取方式从标准IO(键盘)中读取数据,所以要先把标准IO(System.in)转换成字符导向的stream,再进行BufferedReader封装。   
  23.   
  24. //2.   从一个String对象中读取数据    
  25. StringReader   in2   =   new   StringReader(s2);    
  26. int   c;    
  27. while((c   =   in2.read())   !=   -1)    
  28. System.out.println((char)c);    
  29. in2.close();    
  30. // 要以字符的形式从一个String对象中读取数据,所以要产生一个StringReader类型的stream。   
  31.   
  32. //3.   从内存取出格式化输入    
  33. try{    
  34. DataInputStream   in3   =      
  35. new   DataInputStream(    
  36. new   ByteArrayInputStream(s2.getBytes()));    
  37. while(true)    
  38. System.out.println((char)in3.readByte());      
  39. }    
  40. catch(EOFException   e){    
  41. System.out.println( "End   of   stream ");    
  42. }    
  43.   
  44. //4.   输出到文件    
  45. try{    
  46. BufferedReader   in4   =    
  47. new   BufferedReader(    
  48. new   StringReader(s2));    
  49. PrintWriter   out1   =    
  50. new   PrintWriter(    
  51. new   BufferedWriter(    
  52. new   FileWriter( "F:\\nepalon\\   TestIO.out ")));    
  53. int   lineCount   =   1;    
  54. while((s   =   in4.readLine())   !=   null)    
  55. out1.println(lineCount++   +   ": "   +   s);    
  56. out1.close();    
  57. in4.close();    
  58. }    
  59. catch(EOFException   ex){    
  60. System.out.println( "End   of   stream ");    
  61. }    
  62. // 对String对象s2读取数据时,先把对象中的数据存入缓存中,再从缓冲中进行读取;对TestIO.out文件进行操作时,先把格式化后的信息输出到缓存中,再把缓存中的信息输出到文件中。   
  63.   
  64. //5.   数据的存储和恢复    
  65. try{    
  66. DataOutputStream   out2   =      
  67. new   DataOutputStream(    
  68. new   BufferedOutputStream(    
  69. new   FileOutputStream( "F:\\nepalon\\   Data.txt ")));    
  70. out2.writeDouble(3.1415926);    
  71. out2.writeChars( "\nThas   was   pi:writeChars\n ");    
  72. out2.writeBytes( "Thas   was   pi:writeByte\n ");    
  73. out2.close();    
  74. DataInputStream   in5   =    
  75. new   DataInputStream(    
  76. new   BufferedInputStream(    
  77. new   FileInputStream( "F:\\nepalon\\   Data.txt ")));    
  78. BufferedReader   in5br   =    
  79. new   BufferedReader(    
  80. new   InputStreamReader(in5));    
  81. System.out.println(in5.readDouble());    
  82. System.out.println(in5br.readLine());    
  83. System.out.println(in5br.readLine());    
  84. }    
  85. catch(EOFException   e){    
  86. System.out.println( "End   of   stream ");    
  87. }    
  88. // 对Data.txt文件进行输出时,是先把基本类型的数据输出屋缓存中,再把缓存中的数据输出到文件中;对文件进行读取操作时,先把文件中的数据读取到缓存中,再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble(),所以为了正确显示。也要以基本类型的形式进行读取。    
  89.   
  90. //6.   通过RandomAccessFile操作文件    
  91. RandomAccessFile   rf   =    
  92. new   RandomAccessFile( "F:\\nepalon\\   rtest.dat ",   "rw ");    
  93. for(int   i=0;   i <10;   i++)    
  94. rf.writeDouble(i*1.414);    
  95. rf.close();    
  96.   
  97. rf   =   new   RandomAccessFile( "F:\\nepalon\\   rtest.dat ",   "r ");    
  98. for(int   i=0;   i <10;   i++)    
  99. System.out.println( "Value   "   +   i   +   ": "   +   rf.readDouble());    
  100. rf.close();    
  101.   
  102. rf   =   new   RandomAccessFile( "F:\\nepalon\\   rtest.dat ",   "rw ");    
  103. rf.seek(5*8);    
  104. rf.writeDouble(47.0001);    
  105. rf.close();    
  106.   
  107. rf   =   new   RandomAccessFile( "F:\\nepalon\\   rtest.dat ",   "r ");    
  108. for(int   i=0;   i <10;   i++)    
  109. System.out.println( "Value   "   +   i   +   ": "   +   rf.readDouble());    
  110. rf.close();    
  111. }    
  112. }   

        看了以上详解说明,是不是对Java输入输出流类的概念有了更清晰的认识,对它们的使用也更得心应手了呢?

本文发布:Android开发网
本文地址:http://www.teaching4real.com/android/course/17.html
2012年4月25日
发布:鸡啄米 分类:Android开发教程 浏览: 注册送白菜网:2