java.IO的操作基础

chameleon110

                                                                                                节点流类型(一根管直接插到下面的类型上,下面的管道指的是线程和线和之间的通讯)

类型 字符流 字节流 File FileReader FileInputStream  FileWriter FileOutputStream  Memory ArrayCharArrayReaderByteArrayInputStream CharArrayWriterByteArrayOutputStreamMemory StringStringReader StringBufferInputStream StringWriter Pipe(管道)PipedReaderPipedInputStream PipedWriterPipedOutputStream
1.1 对内存的操作 1.1.1把内存数据读入Stream
   1.ByteArraryInputStream: 把内存中的一个缓冲区作为InputStream
   2.CharArrayInputStream ：
1.1.2把Stream数据写入内存
   1.ByteArraryOutputStream: 把Stream信息写入内存
   2.CharArraryOutputStream: 以字符方式
1.2 对文件的操作 1.2.1把文件数据读入Stream
   1.FileInputStream :  把一个文件作为InputStream,实现对文件的读取操作
   2.FileReader      :  以字符导向
1.2.2把Stream数据输入文件
   1.FileOutputStream:  把Stream数据写入文件
   2.FileWriter      :  以字符方式
1.3 对String的操作 1.3.1StringBufferInputStream : 把一个String对象作为InputStream
1.3.2
1.4 对Pipe的操作 1.4.1把pipe数据读入Stream
    1.PipedInputStream : 把管道数据读入Stream
    2.PipedReader     ：
1.4.2把Stream数据写入Pipe
   1.PipedOutputStream
   2.PipedReader       :
大多初学者对java I/O系统提供了如此多的类而感到不知所错，本文中将会做一下梳理
流的概念
流（stream）的概念源于UNIX中的管道（pipe）的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。
    一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。   
    流的方向是重要的，根据流的方向，流可以分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出流，只能往往输入流写，而不能读取。其实输入/输出是想对于内存来说的。
    实际上，流的源端和目的端可简单地看成是字节的生产者和消费者，对于输入流，可不必关心它的源端是什么，只要简单地从流中读数据，而对输出流，也可不知道它的目的端，只是简单地往流中写数据。
    java.io包中的类对应两类流，一类流直接从指定的位置（如磁盘文件或内存区域）读或写，这类流称为结点流，其他的流则称为过滤流（包装流）
    过滤流：一些流可以从文件以及其他地方接收字节，另一些流可以将字节组合成更有用的数据类型。将一个已经存在的流传递给另一个流的构造方法，将这两种流结合起来，结合后的流被称为过滤流。
    过滤器输入流往往是以其它输入流作为它的输入源，经过过滤或处理后再以新的输入流的形式提供给用户，过滤器输出流也类似。
  
    java的常用输入、输出流
    其实都是继承自4个抽象类，分别是
    基于单字节的InputStream,OutputStream类
    基于双字节的Unicode代码单元的 Reader， Writer类
    一旦打开输入流后，程序就可从输入流串行地读数据。
从输入流读数据的过程一般如下：
open a stream
while more information
    read information
close the stream
类似地，程序也能通过打开一个输出流并顺序地写入数据来将信息送至目的端。
往输出流写数据的过程一般如下：
open a stream
while more information
    write information
close the stream
java.io包中的stream类根据它们操作对象的类型是字符还是字节可分为两大类： 字符流和字节流。
        InputStream,OutputStream类仅仅读取和写入单个的字节和字节数组，它们没有读取和写入字符串和数值的方法。
    由于以字节为单位的流处理存储为Unicode码的信息很不方便（Unicode的每个代码单元使用了两个字节），所以有了一个专门的类层次来处理Unicode字符，这些类继承于抽象类Reader和Writer。
   
    1.1 以字节为导向的stream

以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：
1。input　stream：
1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
2) StringBufferInputStream：把一个String对象作为InputStream   ---已过时。 此类未能正确地将字符转换为字节。从 JDK 1.1 开始，从字符串创建流的首选方法是通过 StringReader 类进行创建。
3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
4) PipedInputStream：实现了pipe的概念，主要在线程中使用
5) SequenceInputStream：把多个InputStream合并为一个InputStream
2。Out　stream
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型：
1)。Input　Stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应
2。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。
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集
OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
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) DataIOutStream：往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) 可以直接跳到文件中指定的位置
4. I/O应用的一个例子
import java.io.*;
public class TestIO{
        public static void main(String[] args)
                                                                        throws IOException{
//1.以行为单位从一个文件读取数据
/*当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，
        再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
*/
        BufferedReader in = new BufferedReader(new FileReader("F:\\java\\TestIO.java"));
                String s, s2 = new String();
                while((s = in.readLine()) != null)
                        s2 += s + "\n";
                in.close();
//1b. 接收键盘的输入
/*由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要
        先把标准IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。
*/
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter a line:");
        System.out.println(stdin.readLine());
//2. 从一个String对象中读取数据
/*
        要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。
*/
        StringReader in2 = new StringReader(s2);
        int c;
        while((c = in2.read()) != -1)
                System.out.println((char)c);
        in2.close();
//3. 从内存取出格式化输入
//把内存中的一个缓冲区作为DataInputStream使用
                try{
                        DataInputStream in3 = new DataInputStream(new ByteArrayInputStream(s2.getBytes()));
                        while(true)
                                System.out.println((char)in3.readByte());
                }catch(EOFException e){
                        System.out.println("End of stream");
                }
//4. 输出到文件
/*对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，
        先把格式化后的信息输出        到缓存中，再把缓存中的信息输出到文件中。
*/
        try{
                BufferedReader in4 = new BufferedReader(new StringReader(s2));
                PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter("F:\\java\\ TestIO.out")));
                int lineCount = 1;
                while((s = in4.readLine()) != null)
                        out1.println(lineCount++ + "：" + s);
                out1.close();
                in4.close();
        }        catch(EOFException ex){
                ystem.out.println("End of stream");
        }
//5. 数据的存储和恢复
/*对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文件中的
数据读取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以
为了正确显示。也要以基本类型的形式进行读取。
*/
        try{
                DataOutputStream out2 = new DataOutputStream(new BufferedOutputStream(        new FileOutputStream("F:\\java\\ Data.txt")));
                out2.writeDouble(3.1415926);
                out2.writeChars("\nThas was pi:writeChars\n");
                out2.writeBytes("Thas was pi:writeByte\n");
                out2.close();
                DataInputStream in5 =        new DataInputStream(        new BufferedInputStream(new FileInputStream("F:\\java\\ Data.txt")));
                BufferedReader in5br = new BufferedReader(        new InputStreamReader(in5));
                System.out.println(in5.readDouble());
                System.out.println(in5br.readLine());
                System.out.println(in5br.readLine());
        }        catch(EOFException e){
                        System.out.println("End of stream");
        }
//6. 通过RandomAccessFile操作文件
//通过RandomAccessFile类对文件进行操作。
RandomAccessFile rf =new RandomAccessFile("F:\\java\\ rtest.dat", "rw");
for(int i=0; i<10; i++)
        rf.writeDouble(i*1.414);
rf.close();
rf = new RandomAccessFile("F:\\java\\ rtest.dat", "r");
for(int i=0; i<10; i++)
        System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
rf = new RandomAccessFile("F:\\java\\ rtest.dat", "rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();
rf = new RandomAccessFile("F:\\java\\ rtest.dat", "r");
for(int i=0; i<10; i++)
        ystem.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}
                                       
               
               
               
               
               
               
               
               
               
               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/61975/showart_1791987.html