关于输入输出流的问题？

java.io 包The Stream classes are divided into two class hierarchies: characters stream classes and bytes stream calsses. (1) Characters Input Stream Abstract class for reading character streams. 
Reader 
    |  Reader  >> Program 
 + BufferedReader 
    |            | Reader  >> Program  (keeping track of line numbers.) 
  |      + LineNumberReader 
    |    An charArray >> Program 
 + CharArrayReader 
    |  InputStream (byte ) >>  Program  (char ) 
 + InputStreamReader 
    |            |      File  >>  Program 
    |      + FileReader 
    |  Abstract class for reading filtered character streams. 
 + FilterReader 
    |            | Reader  >> Program   ( push chars back into the stream) 
    |      + PushbackReader 
    |  Piped character streams  >> Program 
 + PipedReader 
    |      String. >> Program 
 + StringReader (2) Characters Output Stream Abstract class  for writing to character streams.. 
Writer 
    |  Program  >>  Writer 
 + BufferedWriter 
    |    Program  >>  A char Array . 
 + CharArrayWriter 
    | Program(char )   >>   OutputStream (byte ) 
 + OutputStreamWriter 
    |              | Program >> File. 
    |       + FileWriter 
    |  Abstract class for writing filtered character streams.. 
 + FilterWriter 
    |  Program  >>  Piped character streams 
 + PipedWriter 
    |      Program  >> String 
 + StringWriter 
    |    Program  >> OutputStream or Writer 
 + PrintWriter ( formatted representations of objects) (3) Bytes Input Stream Abstract class for reading bytes streams. 
InputStream 
    |  File  >> Program 
 + FileInputStream 
    |    piped output stream  >> Program 
 + PipedInputStream 
    | contains some other input streams 
 + FilterInputStream 
    |          |   InputStream  >> Program ( read primitive data ) 
    |    + DataInputStream 
    |          |  InputStream   >>  Program 
    |    + BufferedInputStream 
    |          |  InputStream   >>  Program 
    |    + PushbackInputStream 
    |          |   InputStream   >>  Program (maintains a checksum of the data) 
    |    + util.zip.CheckedInputStream 
    |          |   InputStream   >>  Program  (uncompressing data) 
    |       + util.zip.InflaterInputStream 
    |         |            |   InputStream  >> Program  (mpressed data in  GZIP format.) 
  |     |     +GZIPInputStream 
    |         |           |   InputStream  >> Program  (mpressed data in  ZIP format.) 
  |     |    +ZIPInputStream 
    |          |   InputStream   >>  Program  (updates the associated message digest) 
  |     + security.DigestInputStream 
    |          |   InputStream   >>  Program  (processed by the Cipher) 
    |       + javax.crypto.CipherInputStream 
    |          |   InputStream   >>  Program  (Monitors the progress of reading) 
    |       + swing.ProgressMonitorInputStream 
    |  A byte Array >> Program 
 + ByteArrayInputStream 
    |    InputStream list  or InputStream's Enumeration  .>> Program 
 + SequenceInputStream 
    | InputStream   >>  Program  (processing Object ) 
 + ObjectInputStream 
    | InputStream   >>  Program   (processing audio file or stream ) 
 + javax.sound.sampled.AudioInputStream (4) Bytes Output Stream Abstract class for writing bytes streams. 
OutputStream 
    |  Program  >> File 
 + FileOutputStream 
    |    Program  >> piped output stream 
 + PipedOutputStream 
    | contains some other output streams 
 + FilterOutputStream 
    |          | Program   >> OutputStream    ( write primitive data ) 
    |     + DataOutputStream 
    |          |  Program    >>  OutputStream 
    |     + BufferedOutputStream 
    |          | Program    >>  OutputStream 
    |     + PrintStream 
    |          |   Program >> OutputStream  (maintains a checksum of the data) 
    |     + util.zip.CheckedOutputStream 
    |          |   Program    >>   OutputStream  (compressing data) 
    |        + util.zip.DeflaterOutputStream 
    |         |         |  Program   >> OutputStream  (mpressed data in  GZIP format.) 
  |     |   + GZIPOutputStream 
    |         |        | Program    >> OutputStream  (mpressed data in  ZIP format.) 
  |     |   + ZIPOutputStream 
    |          |  Program  >>  OutputStream   (updates the associated message digest) 
  |     + security.DigestOutputStream 
    |          |  Program   >>  OutputStream     (processed by the Cipher) 
    |        + javax.crypto.CipherOutputStream 
    |  Program   >>  A byte Array 
 + ByteArrayOutputStream 
    | Program   >>  OutputStream   (processing Object ) 
 + ObjectOutputStream (5) Other Classes 
Represents a file on the native file system. 
java.io.File 
Supports both reading and writing to a random access file. 
java.io.RandomAccessFile 
Breaks the contents of a stream into tokens. 
java.io.StreamTokenizer 
Breaks a string into tokens. 
java.util.StringTokenizer 

解决方案 »

  1.   

    文件流
    1. 文件读写  (File FileReader/Writer) Task:  Copy the content of "farrago.txt" into "outagain.txt". import java.io.*; 
    public class Copy { 
       public static void main(String[] args) 
            throws IOException {    File inFile = new File("farrago.txt"); 
       File outFile = new File("outagain.txt");    FileReader in = new FileReader(inFile); 
       FileWriter out = new FileWriter(outFile);    int c; 
       while ((c = in.read()) != -1) 
          out.write(c); 
       in.close(); 
       out.close(); 
      } 
    } 
      

  2.   

    看看JAVA文档  
    看看是这样继承的
      

  3.   

    I/O流提供一条通道程序，可以使用这条通道把源中的字节序列送给目的地。把输入流的指向称做源，程序从指向源的输入流中读取源中的数据。而输出流的指向是字节要去的一个目的地(或用户)，程序通过向输出流中写入数据把信息传递到目的地。虽然I/O流经常与磁盘文件存取有关,但是程序的源和目的地也可以是键盘、鼠标、内存或显示器窗口。
    Java的I/O流库提供大量的流类(在包java.io中）。但是，所有输入流类都是InputStream（输入流）抽象类的子类，而所有输出流都是OutputStream(输出流) 抽象类的子类。
    1-----FileInputStream类
    FileInputStream（String name）
    FileInputStream(File file)
    使用文件输入流读取文件处理I/O异常：当您使用文件输入流构造器建立通往文件的输入流时，可能会出现错误（也被称为异常）关闭流2-----FileOutputStream类
    FileOutputStream（String name）
    FileOutputStream(File file)
    FileOutputStream(FileDescriptor fdObj)
    write的格式如下：
    public void write(byte b[]) :写b.length个字节到输出流。
    public void.write(byte b[],int off,int len)：从给定字节数组中起始于偏移量off处写len个字节到输出流，参数  b： 数据；off：数据的起始偏移量；len：要输出的字节数。3-----FileReader类和FileWriter类FileReader（String  filename）,
    FileWriter (String  filename)。
    FileReader file=new FileReader("Student.txt");
    BufferedReader（Reader in），
    它能够读取文本行，方法是readLine()。
    通过向BufferedReader传递一个Reader对象（如FileReader的实例），来创建一个BufferedReader对象，如下列代码：
    BufferedReader  in= BufferedReader(new FileReader("Student.txt"));
    然后再从流in中读取Student.txt。下面是一段创建FileWrite对象的代码，可以使用该对象写名hello.txt的文件。
    FileWriter tofile=new FileReader("hello.txt");
    我们用Java的BufferedReader类创建一个流，接到流 tofile上 ，然后使用BufferedReader类的方法
    write(String s,int  off ,int  len)
    把字符串s写到hello.txt中，参数off 是s开始处的偏移量，len是写入的字符数量。如：
    BufferedWriter  out= BufferedWriter(new FileReader("hello.txt"));
    out.wtite("how are you",0,s.length());
    但out.Wtite("how are you",0,s.length())只是将字符串"how are you"写入了缓存区，如想写入到文件，必须在执行语句
    out.flush();
    将缓存区的字符串写入文件hello.txt。
    4-----RandomAccessFile类
    RandomAccessFile类创建的流与前面的输入、输出流不同，RandomAccessFile类既不是输入流类InputStream类的子类，也不是输出流类OutputStram类的子类流。但是RandomAccessFile类创建的流的指向既可以作为源也可以作为目的地,换句话说,当我们想对一个文件进行读写操作时,我们可以创建一个指向该文件的RandomAccessFile流即可，这样我们既可以从这个流中读取这个文件的数据，也通过这个流写入数据给这个文件。
    RandomAccessFile类的两个构造方法：
    RandomAccessFile(String name,String mode)：参数name 用来确定一个文件名，给出创建的流的源（也是流目的地），参数mode取r（只读）或rw（可读写），决定创建的流对文件的访问权利。
    RandomAccessFile(File file,String mode): 参数file 是一个File对象，给出创建的流的源（也是流目的地），参数mode取r（只读）或rw（可读写），决定创建的流对文件的访问权利。创建对象时应捕获FileNotFoundException异常；当流进行读写操作时，应捕获IOException异常。
    RandomAccessFile类中有一个方法：seek(long a),用来移动RandomAccessFile流指向的文件的指针，其中参数 a 确定文件指针距离文件开头的字节位置。另外流还可以调用getFilePointer()方法获取当前文件的指针的位置（RandomAccessFile类的一些方法见下表）,RandomAccessFile流对文件的读写比顺序读写更为灵活。方法  描述
    close()  关闭文件
    getFD()  获取文件的FileDescriptor
    getFilePointer()  获取文件指针的位置
    length()  获取文件的长度
    read()  从文件中读取一个字节的数据
    readBoolean()  从文件中读取一个布尔值，0代表false;其他值代表true
    readByte()  从文件中读取一个字节
    readChar()  从文件中读取一个字符(2个字节)
    readDouble() 从文件中读取一个双精度浮点值（8个字节）
    readFloat()  从文件中读取一个单精度浮点值（4个字节）
    readFully(byte b[])  读b.length字节放入数组b，完全填满该数组
    readInt()  从文件中读取一个int值（4个字节）
    readLine()  从文件中读取一个文本行
    readlong()  从文件中读取一个长型值（8个字节）
    readShort()  从文件中读取一个短型值（2个字节）
    readUnsignedByte()  从文件中读取一个无符号字节（1个字节）
    readUnsignedShort()  从文件中读取一个无符号短型值（2个字节）
    readUTF()  从文件中读取一个UTF字符串
    seek()  定位文件指针在文件中的位置
    SetLength(long  newlength)  设置文件的长度
    SkipBytes(int n)  在文件中跳过给定数量的字节
    write(byte b[])  写b.length个字节到文件
    writeBoolean(boolean v)  把一个布尔值作为单字节值写入文件
    writeByte(int v)  向文件写入一个字节
    writeBytes(String s)  向文件写入一个字符串
    writeChar(char c)  向文件写入一个字符
    writeChars(String s)  向文件写入一个作为字符数据的字符串
    writeDouble(double v)  向文件写入一个双精度浮点值
    writeFloat(float v)  向文件写入一个单精度浮点值
    writeInt(int v)  向文件写入一个int值
    writeLong(long v)  向文件写入一个长型int值
    writeShort(int v)  向文件写入一个短型int值
    writeUTF(String s)  写入一个UTF字符串
    5-----管道流
    PipedInputStream类和PipedOutputStream类
    PipedInputStream 类创建的对象称为一个输入管道，PipedOutputStream类创建的对象称为一个输出管道
    PipedInputStream类的构造方法：
    （1）PipedInputStream（）：创建一个管道输入流，它还没有被连接。在使用它之前必须连接到一个管道输出流。比如，
    PipedInputStream in=new PipedInputStream();
    in 处于等待连接状态，要使用in，必须再使用PipedOutputStream类的构造方法创建一个等待连接的管道输出流：
    PipedOutputStream  out=new PipedOutputStream();
    然后使用connect(PipedOutputStream  c)方法把in和out相连接：
    in.connect(out);
    （2）PipedInputStream（PipedOutputStream  a）：创建一个管道输入流，它被连接到由参数a指定的管道输出流。
    PipedOutputStream类的构造方法：
    （1）PipedOutputStream（）:创建一个管道输出流，它还没有被连接。在使用它之前必须连接到一个管道输入流，比如，
    PipedOutputStream out=new PipedOutputStream ();
    out 处于等待连接状态，要使用out，必须再使用PipedInputStream类的构造方法创建一个等待连接的管道输入流：
    PipedInputStream  in=new PipedInputStream ();
    然后使用connect(PipedInputStream  c)方法把in和out相连接：
    out.connect(in);
    （2）PipedOutputStream（PipedInputStream  a）:创建一个管道输出 流，它被连接到由参数a指定的管道输入流。
    创建管道流都必须捕获IOException异常，即对象的创建应放到try {} catch(){}
    块语句中，例如，
    try{ PipedInputStream  out=new PipedInputStream ();}
    catch(IOException e){}
    PipedInputStream类的一些方法：
    public int read()：从管道输入流中读取下一字节。字节值被作为0~255之间的一个整数返回，到达流的末尾返回 –1。
    public int read(byte b[],int off,int len)：从管道输入流读取最多len个字节放到一个字节数组，参数 off指定放置这 len个字节在数组b中时的起始位置。返回读取的字节数目。
    public void connect(PipedOutputStream  a)：把当前管道输入流和参数a指定的管道输出流连接起来。
    close()：关闭流。
    上面的方法在使用时也必须捕获 IOException异常。
    PipedOutputStream类的一些方法：
    public void write(int b)：写b个字节到这个管道输出流。
    public write(byte b[],int off,int len)：从字节数组起始偏移量 off处写len个字节到管道输出流。
    public void connect(PipedIntputStream  a)：把当前管道流和参数a指定的管道输入流连接起来。
    close()：关闭流。
    上面的方法在使用时也必须捕获 IOException异常。
    我们对流水式作业都很熟悉，我们可以把流水式作业中的每道工序看作一个线程，一个线程和下一个线程之间由“传输带”传输数据。
      

  4.   

    TO  canghaiyisujsg (沧海一粟) :
                       兄弟，静下心来仔细看看书比在这提问讨论好的多！
      

  5.   

    谢谢各位前辈的照顾，也谢谢zhengoodman 与 softgq的辛勤劳动，真的受益很大，明白了不少。谢谢了！！！顺便问一下，从哪儿可以搞到一些练习题做一下，照着课本的例子打太没劲了。