Java入门

13年前

1    流的概念

     stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样，如下图：

 

在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型：

(1)字节流

表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据，如图象和声音。

(2)字符流

以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。

区别：

Reader和Writer要解决的，最主要的问题就是国际化。原先的I/O类库只支持8位的字节流，因此不可能很好地处理16位的Unicode字符流。Unicode是国际化的字符集(更何况Java内置的char就是16位的Unicode字符)，这样加了Reader和Writer之后，所有的I/O就都支持Unicode了。此外新类库的性能也比旧的好。

但是，Read和Write并不是取代InputStream和OutputStream，有时，你还必须同时使用"基于byte的类"和"基于字符的类"。为此，它还提供了两个"适配器(adapter)"类。InputStreamReader负责将InputStream转化成Reader，而OutputStreamWriter则将OutputStream转化成Writer。实际上是通过byte[]和String来关联。在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的。

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

字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串；而字节流处理单元为1个字节，操作字节和字节数组，可用于任何类型的对象，包括二进制对象，但是不能直接处理Unicode字符。字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好。如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点。

2    流的层次结构

java将读取数据对象称为输入流，能向其写入的对象叫输出流。

1)     基于字节的输入流

l  FileInputStream：把一个文件作为InputStream，从本地文件系统中读取数据字节，实现对文件的读取操作

l  ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用，从内存数组中读取数据字节

l  ObjectInputStream：对象输入流。从文件中把对象读出来重新建立。对象必须要实现Serializable接口。对象中的transient和static类型的成员变量不会被读取和写入。

l  PipedInputStream：实现了pipe的概念，从线程管道中读取数据字节，主要在线程中使用。管道输入流是指一个通讯管道的接收端。一个线程通过管道输出流发送数据，而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯

l  SequenceInputStream：把多个InputStream合并为一个InputStream，当到达流的末尾时从一个流转到另一个流，“序列输入流”类允许应用程序把几个输入流连续地合并起来，并且使它们像单个输入流一样出现。

l  StringBufferInputStream：把一个String对象作为InputStream，从字符串中读取数据字节

l  FilterInputStream：过滤器流java.io.FilterInputStream，过滤器流即能把基本流包裹起来，提供更多方便的用法。类的构造方法为FilterInputStream(InputStream)，在指定的输入流之上，创建一个输入流过滤器。常用的子类如下：

u  BufferedInputStream：缓冲区对数据的访问，以提高效率

u  DataInputStream：从输入流中读取基本数据类型，如int、float、double或者甚至一行文本

u  LineNumberInputStream：在翻译行结束符的基础上，维护一个计数器，该计数器表明正在读取的是哪一行。

u  PushbackInputStream：允许把数据字节向后推到流的首部

l  System.in

从用户控制台读取数据字节

在System类中， in是InputStream类的静态对象，因此，out和err可以引用PrintStream类的成员方法。如：System.in.read()。

2)     基于字节的输出流

l  FileOutputStream：把信息存入文件中

l  ByteArrayOutputStream：把信息存入内存中的一个缓冲区中，该类实现一个以字节数组形式写入数据的输出流

l  PipedOutputStream：实现了pipe的概念，主要在线程中使用。管道输出流是指一个通讯管道的发送端。 一个线程通过管道输出流发送数据， 而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。

l  SequenceOutputStream：把多个OutStream合并为一个OutStream

l  FilterOutputStream：类似于FilterInputStream，OutputStream也提供了过滤器输出流。

l  ObjectOutputStream：对象输出流。对象必须要实现Serializable接口。对象中的transient和static类型的成员变量不会被读取和写入。

l  System.out

输出数据字节到用户控制台

在System类中，out和err是PrintStream类的静态对象，因此，out和err可以引用PrintStream类的成员方法。如：System.out.write (int a)。

3)     基于字符的输入流

l  CharArrayReader：与ByteArrayInputStream对应，从字符数组中读取数据

l  StringReader：与StringBufferInputStream对应，从字符数组中读取数据

l  FileReader：与FileInputStream对应，从本地文件系统中读取字符序列

l  PipedReader：与PipedInputStream对应，从线程管道中读取字符序列

l  InputStreamReader：InputStreamReader是从输入流中读取数据，连接输入流于读取器。如： new InputStreamReader(System.in)

l  BufferedReader：缓冲数据的访问，以提高效率

u  LineNumberReader（BufferedReader的子类）：维护一个计数器，该计数器表明正在读取的是哪一行。

l  FilterReader（抽象类）：提供一个类创建过滤器时可以扩展这个类

u  PushbackReader（FilterReader的子类）：允许把文本数据推回到读取器的流中。

这些过滤器读取器都可以传入一个Reader作为构造方法的参数。

4)     基于字符的输出流

l  CharArrayWrite：与ByteArrayOutputStream对应

l  StringWrite：无与之对应的以字节为导向的stream

l  FileWrite：与FileOutputStream对应

l  PipedWrite：与PipedOutputStream对应

3    InputStream类

Inputstream类和Outputstream类都为抽象类，不能创建对象，可以通过子类来实例化。

InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法。Reader也有完全相同的3个read接口。Inputstream类中的常用方法：

1)     public abstract int read( )：读取一个byte的数据，返回读到的数据(高位补0的int类型值),如果返回-1，表示读到了输入流的末尾。

2)     public int read(byte  b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数, 如果返回-1，表示读到了输入流的末尾。该方法实际上是调用下一个方法实现的。

3)     public int read(byte  b[ ], int  off, int  len)：从输入流中最多读取len个字节的数据，存放到数组b中，返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。off指定在 数组b中存放数据的起始偏移位置。

4)     public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用。

5)     public long skip(long  n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取。

6)     public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭。

7)     void mark(int readlimit) ：在输入流的当前位置放置一个 标记，如果读取的字节数多于readlimit设置的值，则流忽略这个标记。在IutputStream类中实际是一个空实现。

8)     void reset() ：返回到上一个标记。

9)     boolean markSupported() ：测试当前流是否支持mark和reset方法。如果支持，返回true，否则返回false。在IutputStream类中实际是一个空实现。

4    OutputSteam类

OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的，Writer同样提供了相同的三个write方法。

1)     public abstract void write(int  b) ：先将int转换为byte类型，把低字节写入到输出流中。

2)     public void write(byte  b[ ])：将参数b中的字节写到输出流。

3)     public void write(byte  b[ ], int  off, int  len) ：将参数b的从偏移量off开始的len个字节写到输出流。

4)     public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。只对使用了缓冲的流类起作用。在OutputStream类中实际是一个空实现。

5)     public void close( ) : 关闭输出流并释放与流相关的系统资源。

注意：

1)     上述各方法都有可能引起异常。

2)     InputStream和OutputStream都是抽象类，不能创建这种类型的对象。 

5    FileInputStream和FileOutputStream

5.1FileInputStream

FileInputStream类是InputStream类的子类，用来处理以文件作为数据输入源的数据流。使用方法：

方式1：

File fin=new File("d:/abc.txt");

FileInputStream  in=new FileInputStream(fin);

方式2：

FileInputStream  in=new FileInputStream("d: /abc.txt");

方式3：

构造函数将 FileDescriptor()对象作为其参数。

FileDescriptor() fd=new FileDescriptor();

FileInputStream f2=new FileInputStream(fd);

 

从指定文件中读出数据：

view plaincopy to clipboardprint?

1.  import java.io.*;  

2.  lass StreamTest{  

3.      public static void main(String[] args)throws Exception{  

4.          FileInputStream fis=new FileInputStream("testoutput.txt");  

5.          byte[] buf=new byte [100];  

6.          int len=fis.read(buf);  

7.         System.out.println(new String(buf,0,len));//由于buf是大小为100的缓冲区，为 了输出有效字符使用String类的构造方法String(byte[]  bytes, int offset, int length)实现输出  

8.          fis.close();  

9.      }  

10. }  

 

 

 

 

5.2FileOutputStream

FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象。

创建一个文件流对象有两种方法：

方式1：

File f=new File("d:/abc.txt");

FileOutputStream  out=new FileOutputStream (f);

方式2：

FileOutputStream out=new

FileOutputStream("d:/abc.txt");

方式3：

构造函数将 FileDescriptor()对象作为其参数。

FileDescriptor() fd=new FileDescriptor();

FileOutputStream f2=new FileOutputStream(fd);

方式4：

构造函数将文件名作为其第一参数，将布尔值作为第二参数。

FileOutputStream f=new FileOutputStream("d:/abc.txt",true);

注意：

1)     文件中写数据时，若文件已经存在，则覆盖存在的文件；

2)     文件的读/写操作结束时，应调用close方法关闭流。

 

向指定文件写入数据：

view plaincopy to clipboardprint?

1.  import java.io.*;  

2.  class StreamTest{  

3.     public static void main(String[] args)throws Exception{  

4.          FileOutputStream fos=new FileOutputStream("testoutput.txt");  

5.          fos.write("Hello World".getBytes ());  

6.          fos.close();  

7.      }  

8.  }  

程序中使用到FileOutputStream类的方法void write(byte[] b) ，所以从写入字符串" Hello World "通过String类的方法getBytes()得到字节数组b，成功进行写入。

6    ObjectOutputStream和ObjectInputStream

ObjectOutputStream和ObjectInputStream可以利用对象流对对象进行序列化。

在一个程序运行的时候，其中的变量数据是保存在内存中的，一旦程序结束这些数据将不会被保存，一种解决的办法是将数据写入文件，而Java中提供了一种机制，它可以将程序中的对象写入文件，之后再从文件中把对象读出来重新建立。这就是所谓的对象序列化Java中引入它主要是为了RMI（Remote Method Invocation）和Java Bean所用，不过在平时应用中，它也是很有用的一种技术。

所有需要实现对象序列化的对象必须首先实现Serializable接口。下面看一个例子：

view plaincopy to clipboardprint?

1.  import java.io.*;  

2.  import java.util.*;  

3.  public class Logon implements Serializable {  

4.         private Date date = new Date();  

5.         private String username;  

6.   private transient String password;  

7.  Logon(String name, String pwd){  

8.                username = name;  

9.                password = pwd;  

10.        }  

11.        public String toString(){  

12.               String pwd = (password == null) ? "(n/a)":password;  

13.               return "logon info: \n " + "username: " + username + "\n date: " + date + "\n password: " + pwd;  

14.        }  

15.        public static void main(String[] args)throws IOException, ClassNotFoundException {  

16.               Logon a = new Logon("Morgan", "morgan83");  

17.               System.out.println("logon a = " + a);  

18.               ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out"));  

19.               o.writeObject(a);  

20.               o.close();  

21.               int seconds = 5;  

22.               long t = System.currentTimeMillis() + seconds * 1000;  

23.               while(System.currentTimeMillis() <t) ;  

24.               ObjectInputStream in = new ObjectInputStream(new FileInputStream("Logon.out"));  

25.               System.out.println("Recovering object at " + new Date());  

26.               a = (Logon)in.readObject();  

27.               System.out.println("logon a = " + a);   

28.        }  

29. }  

类Logon是一个记录登录信息的类，包括用户名和密码。首先它实现了接口Serializable，这就标志着它可以被序列化。之后再main方法里ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("Logon.out"));新建一个对象输出流包装一个文件流，表示对象序列化的目的地是文件Logon.out。然后用方法writeObject开始写入。想要还原的时候也很简单ObjectInputStream in = new ObjectInputStream(new FileInputStream("Logon.out"));新建一个对象输入流以文件流Logon.out为参数，之后调用readObject方法就可以了。

需要说明一点，对象序列化有一个神奇之处就是，它建立了一张对象网，将当前要序列化的对象中所持有的引用指向的对象都包含起来一起写入到文件，更为奇妙的是，如果你一次序列化了好几个对象，它们中相同的内容将会被共享写入。这的确是一个非常好的机制。它可以用来实现深层拷贝。

关键字transient在这里表示当前内容将不被序列化，比如例子中的密码，需要保密，所以没有被写入文件。

7    PipedInputStream和PipedOutputStream

PipedInputStream和PipedOutputStream分别从InputStream类和OutputStream类继承，因此它们并不是过滤流类。

    管道流，用于线程间的通信。一个线程的PipedInputStream对象从另一个线程的 PipedOutputStream对象读取。要使管道流有用，必须同时构造管道输入流和管道输出流。

利用线程生产者和消费者问题：

view plaincopy to clipboardprint?

1.  import java.io.*;  

2.  class PipedStreamTest{  

3.      public static void main(String[] args){  

4.          PipedOutputStream pos=new PipedOutputStream();  

5.          PipedInputStream pis=new PipedInputStream();  

6.          try{  

7.              pos.connect(pis);  

8.              new Producer(pos).start();  

9.              new Consumer(pis).start();  

10.         }catch(Exception e){  

11.             e.printStackTrace();  

12.         }  

13.     }  

14. }  

15.   

16. class Producer extends Thread{  

17.     private PipedOutputStream pos;  

18.     Producer(PipedOutputStream pos){  

19.         this.pos=pos;  

20.     }  

21.     public void run(){  

22.         try{  

23.             pos.write("Hello,My friends!".getBytes());  

24.            pos.close();  

25.         }catch(Exception e){  

26.             e.printStackTrace();  

27.         }  

28.     }  

29. }   

30. class Consumer extends Thread{  

31.     private PipedInputStream pis;  

32.     Consumer(PipedInputStream pis){  

33.         this.pis=pis;  

34.    }  

35.     public void run(){  

36.         try{  

37.            byte[] buf=new byte[100];  

38.             int len=pis.read(buf);  

39.             System.out.println(new String(buf,0,len));  

40.             pis.close();  

41.         }catch(Exception e){  

42.             e.printStackTrace();  

43.         }  

44.     }  

45. }  

8    FilterInputStream和FilterOutputStream

java的流类提供了结构化方法，如，底层流和高层过滤流。

而高层流不是从输入设备读取，而是从其他流读取。同样高层输出流也不是写入输出设备，而是写入其他流。

使用“分层对象(layered objects)”，为单个对象动态地，透明地添加功能的做法，被称为Decorator Pattern。Decorator模式要求所有包覆在原始对象之外的对象，都必须具有与之完全相同的接口。这使得decorator的用法变得非常的透明--无论对象是否被decorate过，传给它的消息总是相同的。这也是Java I/O类库要有“filter(过滤器)”类的原因：抽象的“filter”类是所有decorator的基类。Decorator模式常用于如下的情形：如果用继承来解决各种需求的话，类的数量会多到不切实际的地步。Java的I/O类库需要提供很多功能的组合，于是decorator模式就有了用武之地。

为InputStream和OutputStream定义decorator类接口的类，分别是FilterInputStream和FilterOutputStream。

通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。

如果我们要往一个文件中写入数据，我们可以这样操作：

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

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

8.1FilterInputStream

类

功能

构造函数参数

用法

DataInputStream

与DataOutputStream配合使用，这样你就能以一种"可携带的方式(portable fashion)"从流里读取primitives了（int，char，long等）

InputStream

包含了一整套读取primitive数据的接口

BufferedInputStream

使用缓冲区解决"每次要用数据的时候都要进行物理读取"的问题。

InputStream，以及可选的缓冲区的容量

它本身并不提供接口，只是提供一个缓冲区。需要连到一个"有接口的对象(interface object)"。

LineNumberInputStream

跟踪输入流的行号；有getLineNumber( )和setLineNumber(int)方法

InputStream

只是加一个行号，所以还得连一个"有接口的对象"。

PushbackInputStream

有一个"弹压单字节"的缓冲区(has a one byte push-back buffer)，这样你就能把最后读到的那个字节再压回去了。

InputStream

主要用于编译器的扫描程序。可能是为支持Java的编译器而设计的。用的机会不多。

 

8.2FilterOutputStream

类

功能

构造函数参数

用法

DataOutputStream

与DataInputStream配合使用，这样你就可以用一种"可携带的方式(portable fashion)"往流里写primitive了(int, char, long,等)

OutputStream

包含了一整套写入primitive数据的接口

PrintStream

负责生成带格式的输出(formatted output)。DataOutputStrem负责数据的存储，而PrintStream负责数据的显示。  

一个OutputStream以及一个可选的boolean值。这个boolean值表示，要不要清空换行符后面的缓冲区。

应该是OutputStream对象的最终包覆层。用的机会很多。

BufferedOutputStream

用 这个类解决"每次往流里写数据，都要进行物理操作"的问题。也就是说"用缓冲区"。用flush( )清空缓冲区。

OutputStream， 以及一个可选的缓冲区大小

本身并不提供接口，只是加了一个缓冲区。需要链接一个有接口的对象。

8.3DataInputStream和DataOutputStream

DataInputStream类对象可以读取各种类型的数据。

DataOutputStream类对象可以写各种类型的数据；

创建这两类对象时，必须使新建立的对象指向构造函数中的参数对象。例如：

FileInputStream in=new FileInputStream("d:/test.txt");

DataInputStream  din=new DataInputStream(in);

 

向指定文件中写入数据：

view plaincopy to clipboardprint?

1.  import java.io.*;  

2.  class StreamTest{  

3.      public static void main(String[] args)throws Exception{  

4.          FileOutputStream fos=new FileOutputStream("d:/test.txt");  

5.          BufferedOutputStream bos=new BufferedOutputStream(fos);  

6.          DataOutputStream dos=new DataOutputStream(bos);  

7.          byte b=3;  

8.          int i=100;  

9.          boolean bool=false;  

10.         char c='k';  

11.         float f=45.77f;  

12.         dos.writeByte(b);  

13.         dos.writeInt(i);  

14.         dos.writeBoolean(bool);  

15.         dos.writeChar(c);  

16.         dos.writeFloat(f);  

17.         dos.close();  

18.     }  

19. }  

 

从指定文件中读出数据：

view plaincopy to clipboardprint?

1.  import java.io.*;  

2.  class StreamTest{  

3.      public static void main(String[] args)throws Exception{  

4.          FileInputStream fis=new FileInputStream("d:/test.txt");  

5.          BufferedInputStream bis=new BufferedInputStream(fis);  

6.          DataInputStream dis=new DataInputStream(bis);  

7.          System.out.println(dis.readByte());  

8.          System.out.println(dis.readInt());  

9.          System.out.println(dis.readBoolean());  

10.         System.out.println(dis.readChar());  

11.         System.out.println(dis.readFloat());  

12.         dis.close();  

13.     }  

14. }  

 

8.4BufferInputStream和BufferOutputStream

允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据。

BufferInputstream定义了两种构造函数

（1）BufferInputStream b= new BufferInputstream(in);

（2）BufferInputStream b=new BufferInputStream(in,size)

第二个参数表示指定缓冲器的大小。

同样BufferOutputStream也有两种构造函数。一次一个字节的向流中写数据。

向指定文件中写入数据：

view plaincopy to clipboardprint?

1.  import java.io.*;  

2.  class StreamTest{  

3.      public static void main(String[] args)throws Exception{  

4.          FileOutputStream fos=new FileOutputStream("testBuffer.txt");  

5.          BufferedOutputStream bos=new BufferedOutputStream(fos);  

6.          bos.write("Hello BufferedOutputStream!".getBytes());  

7.          bos.close();  

8.      }  

9.  }  

如果不加bos.close();语句，则运行后打开testBuffer.txt文件会查看不到内容，这是因为我们将数据写入了缓冲区，只有结束程序时才写入到指定文件中。bos.close();实现立即写入到指定文件，不同的是这样如果想要继续写入就不用再次打开文件了。

从指定文件中读出数据：

view plaincopy to clipboardprint?

1.  import java.io.*;     

2.  class StreamTest{     

3.      public static void main(String[] args)throws Exception{     

4.          FileInputStream fis=new FileInputStream("d:/test.txt");     

5.          BufferedInputStream bis=new BufferedInputStream(fis);     

6.          byte[] buf=new byte [100];     

7.          int len = bis.read(buf);             

8.          System.out.println(new String(buf,0,len));     

9.          bis.close();     

10.     }     

11. }  

 

8.5Printstream

用于写入文本或基本类型

两种构造函数方法：

PrintStream ps=new PrintStream(out);

PrintStream ps=new PrintStream(out, autoflush)

第二个参数为布尔值，控制每次输出换行符时java是否刷新输出流。

9    Java IO 的一般使用原则

一、按数据来源（去向）分类：

1 、是文件： FileInputStream, FileOutputStream(字节流),FileReader, FileWriter(字符流)

2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream(字节流)

3 、是 Char[]: CharArrayReader, CharArrayWriter(字符流)

4 、是 String: StringBufferInputStream, StringBufferOuputStream (字节流)StringReader, StringWriter(字符流)

5 、网络数据流： InputStream, OutputStream(字节流), Reader, Writer( 字符流 )

二、按是否格式化输出分：

1 、要格式化输出： PrintStream, PrintWriter

三、按是否要缓冲分：

1 、要缓冲： BufferedInputStream, BufferedOutputStream(字节流), BufferedReader, BufferedWriter(字符流)

四、按数据格式分：

1 、二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream 及其所有带 Stream 结束的子类

2 、纯文本格式（含纯英文与汉字或其他编码方式）:Reader, Writer 及其所有带 Reader, Writer 的子类

五、按输入输出分：

1 、输入： Reader, InputStream 类型的子类

2 、输出： Writer, OutputStream 类型的子类

六、特殊需要：

1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader, OutputStreamWriter

2 、对象输入输出： ObjectInputStream, ObjectOutputStream

3 、进程间通信： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4 、合并输入： SequenceInputStream

5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：

首先，考虑最原始的数据格式是什么： 原则四

第二，是输入还是输出：原则五

第三，是否需要转换流：原则六第 1 点

第四，数据来源（去向）是什么：原则一

第五，是否要缓冲：原则三 （特别注明：一定要注意的是 readLine() 是否有定义，有什么比 read, write 更特殊的输入或输出方法）

第六，是否要格式化输出：原则二