【java笔试系列七】I/O整理

一、简介

Java IO主要在java.io包下，分为四大块近80个类：

1、基于字节操作的I/O接口：InputStream和OutputStream

2、基于字符操作的I/O接口：Writer和Reader

3、基于磁盘操作的I/O接口：File

4、基于网络操作的I/O接口：Socket（不在java.io包下）

影响IO性能的无非就是两大因素：数据的格式及存储的方式，前两类主要是数据格式方面的，后两个类是存储方式方面的：本地和网络。所以策划好这两个方面的活动，有助于我们合理使用IO。

         IO流简单来说就是Input和Output流，IO流主要是用来处理设备之间的数据传输，Java对于数据的操作都是通过流实现，而java用于操作流的对象都在IO包中。

分类：

Writer        按操作数据分为：字节流和字符流。 如：Reader和InputStream

        按流向分：输入流和输出流。如：InputStream和OutputStream

IO流常用的基类：

         * InputStream    ，    OutputStream

字符流的抽象基类：

         * Reader       ，         Writer

由上面四个类派生的子类名称都是以其父类名作为子类的后缀：

            如：FileReader和FileInputStream

二、字符流Reader&Writer

1. 字符流简介：

* 字符流中的对象融合了编码表，也就是系统默认的编码表。我们的系统一般都是GBK编码。

* 字符流只用来处理文本数据，字节流用来处理媒体数据。

* 数据最常见的表现方式是文件，字符流用于操作文件的子类一般是FileReader和FileWriter。

2.字符流读写：

注意事项：

* 写入文件后必须要用flush()刷新。

* 用完流后记得要关闭流

* 使用流对象要抛出IO异常

* 定义文件路径时，可以用“/”或者“\\”。

* 在创建一个文件时，如果目录下有同名文件将被覆盖。

* 在读取文件时，必须保证该文件已存在，否则出异常

示例1：在硬盘上创建一个文件,并写入一些文字数据

[java]  view plain  copy

1. class FireWriterDemo {    
2.     public static void main(String[] args) throws IOException {             //需要对IO异常进行处理     
3.     
4.         //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。    
5.         //而且该文件会被创建到指定目录下。如果该目录有同名文件，那么该文件将被覆盖。    
6.     
7.         FileWriter fw = new FileWriter("F:\\1.txt");//目的是明确数据要存放的目的地。    
8.     
9.         //调用write的方法将字符串写到流中    
10.         fw.write("hello world!");    
11.         
12.         //刷新流对象缓冲中的数据，将数据刷到目的地中    
13.         fw.flush();    
14.     
15.         //关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候，必须close();    
16.         fw.write("first_test");    
17.         fw.close();    
18.         //flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。    
19.     
20.     }    
21. }    

示例2：FileReader的reade()方法.

要求：用单个字符和字符数组进行分别读取

示例3：对已有文件的数据进行续写

[java]  view plain  copy

1. import java.io.*;    
2.     
3. class  FileWriterDemo3 {    
4.     public static void main(String[] args) {    
5.             
6.         try {    
7.             //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写    
8.             FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);    
9.             fw.write(" is charactor table?");    
10.             fw.close();    
11.         }    
12.         catch (IOException e) {    
13.             sop(e.toString());    
14.         }    
15.             
16.     }    
17.     
18. /**********************Println************************/    
19.     private static void sop(Object obj)    
20.     {    
21.         System.out.println(obj);    
22.     }    
23. }    

练习：

将F盘的一个文件复制到E盘。 

思考：

其实就是将F盘下的文件数据存储到D盘的一个文件中。

步骤：

1.在D盘创建一个文件，存储F盘中文件的数据。
2.定义读取流和F：盘文件关联。
3.通过不断读写完成数据存储。
4.关闭资源。

源码：

[java]  view plain  copy

1. import java.io.*;    
2. import java.util.Scanner;    
3.     
4. class CopyText {    
5.     public static void main(String[] args) throws IOException {    
6.         sop("请输入要拷贝的文件的路径:");    
7.         Scanner in = new Scanner(System.in);    
8.         String source = in.next();    
9.         sop("请输入需要拷贝到那个位置的路径以及生成的文件名:");    
10.         String destination = in.next();    
11.         in.close();    
12.         CopyTextDemo(source,destination);    
13.     
14.     }    
15.     
16. /*****************文件Copy*********************/    
17.     private static void CopyTextDemo(String source,String destination) {    
18.     
19.         try {    
20.             FileWriter fw = new FileWriter(destination);    
21.             FileReader fr = new FileReader(source);    
22.             char []  buf = new char[1024];     
23.             //将Denmo中的文件读取到buf数组中。    
24.             int num = 0;        
25.             while((num = fr.read(buf))!=-1) {    
26.                                //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符    
27.                 fw.write(new String(buf,0,num));    
28.             }    
29.             fr.close();    
30.             fw.close();    
31.         }    
32.         catch (IOException e) {    
33.             sop(e.toString());    
34.         }    
35.     }    
36.     
37.     
38.     
39. /**********************Println************************/    
40.     private static void sop(Object obj) {    
41.         System.out.println(obj);    
42.     }    
43. }    

三、缓冲区

1. 字符流的缓冲区：BufferedReader和BufferedWreiter

* 缓冲区的出现时为了提高流的操作效率而出现的.

* 需要被提高效率的流作为参数传递给缓冲区的构造函数

* 在缓冲区中封装了一个数组，存入数据后一次取出

BufferedReader示例：

读取流缓冲区提供了一个一次读一行的方法readline，方便对文本数据的获取。
readline()只返回回车符前面的字符，不返回回车符。如果是复制的话，必须加入newLine()，写入回车符

newLine()是java提供的多平台换行符写入方法。

[java]  view plain  copy

1. import java.io.*;    
2.     
3.     
4. class BufferedReaderDemo {    
5.     public static void main(String[] args)  throws IOException {    
6.     
7.         //创建一个字符读取流流对象，和文件关联    
8.         FileReader rw = new FileReader("buf.txt");    
9.     
10.         //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可    
11.         BufferedReader brw = new BufferedReader(rw);    
12.     
13.             
14.         for(;;) {    
15.             String s = brw.readLine();    
16.             if(s==null) break;    
17.             System.out.println(s);    
18.         }    
19.             
20.         brw.close();//关闭输入流对象    
21.     
22.     }    
23. }    

BufferedWriter示例：

[java]  view plain  copy

1. import java.io.*;    
2.     
3.     
4. class BufferedWriterDemo {    
5.     public static void main(String[] args)  throws IOException {    
6.     
7.         //创建一个字符写入流对象    
8.         FileWriter fw = new FileWriter("buf.txt");    
9.     
10.         //为了提高字符写入效率，加入了缓冲技术。    
11.         //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可    
12.         BufferedWriter bfw = new BufferedWriter(fw);    
13.     
14.         //bfw.write("abc\r\nde");    
15.         //bfw.newLine();               这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符    
16.         //用到缓冲区就必须要刷新    
17.         for(int x = 1; x < 5; x++) {    
18.             bfw.write("abc");    
19.             bfw.newLine();                  //java提供了一个跨平台的换行符newLine();    
20.             bfw.flush();    
21.         }    
22.     
23.     
24.     
25.         bfw.flush();                                                //刷新缓冲区    
26.         bfw.close();                                                //关闭缓冲区，但是必须要先刷新    
27.     
28.         //注意，关闭缓冲区就是在关闭缓冲中的流对象    
29.         fw.close();                                                 //关闭输入流对象    
30.     
31.     }    
32. }    

2.装饰设计模式

装饰设计模式：：：：

要求：自定义一些Reader类，读取不同的数据(装饰和继承的区别)
MyReader //专门用于读取数据的类
    |--MyTextReader
        |--MyBufferTextReader
    |--MyMediaReader
        |--MyBufferMediaReader
    |--MyDataReader
        |--MyBufferDataReader

如果将他们抽取出来，设计一个MyBufferReader，可以根据传入的类型进行增强
class MyBufferReader {

    MyBufferReader (MyTextReader text) {}
    MyBufferReader (MyMediaReader media) {}
    MyBufferReader (MyDataReader data) {}
}

但是上面的类拓展性很差。找到其参数的共同类型，通过多态的形式，可以提高拓展性

class MyBufferReader  extends MyReader{
    private MyReader r;                        //从继承变为了组成模式  装饰设计模式
    MyBufferReader(MyReader r) {}
}

优化后的体系：
    |--MyTextReader
    |--MyMediaReader
    |--MyDataReader
    |--MyBufferReader        //增强上面三个。装饰模式比继承灵活，
                              避免继承体系的臃肿。降低类与类之间的耦合性

装饰类只能增强已有的对象，具备的功能是相同的。所以装饰类和被装饰类属于同一个体系

 

 

 

MyBuffereReader类：  自己写一个MyBuffereReader类，功能与BuffereReader相同

[java]  view plain  copy

1. class MyBufferedReader1  extends Reader{                 
2.     private Reader r;    
3.     MyBufferedReader1(Reader r){    
4.         this.r  = r;    
5.     }    
6.     
7.     //一次读一行数据的方法    
8.     public String myReaderline()  throws IOException {    
9.         //定义一个临时容器，原BufferReader封装的是字符数组。    
10.         //为了演示方便。定义一个StringBuilder容器。最终要将数据变成字符串    
11.         StringBuilder sb = new StringBuilder();    
12.         int ch = 0;    
13.         while((ch = r.read()) != -1)    
14.         {    
15.             if(ch == '\r')     
16.                 continue;    
17.             if(ch == '\n')                    //遇到换行符\n,返回字符串    
18.                 return sb.toString();    
19.             else    
20.             sb.append((char)ch);    
21.         }    
22.         if(sb.length()!=0)                    //当最后一行不是以\n结束时候，这里需要判断    
23.             return sb.toString();    
24.         return null;    
25.     }    
26.     /*  
27.     需要覆盖Reader中的抽象方法close()，read();  
28.     */    
29.     public void close()throws IOException {    
30.         r.close();    
31.     }    
32.     
33.     public int read(char[] cbuf,int off, int len)throws IOException {   //覆盖read方法    
34.         return r.read(cbuf,off,len);    
35.     }    
36.     
37.     public void myClose() throws IOException{    
38.         r.close();    
39.     }    
40.     
41.     
42. }    

四、字节流

1.概述：

 

1、字节流和字符流的基本操作是相同的，但是要想操作媒体流就需要用到字节流。

2、字节流因为操作的是字节，所以可以用来操作媒体文件。（媒体文件也是以字节存储的）

3、读写字节流：InputStream   输入流（读）和OutputStream  输出流（写）

4、字节流操作可以不用刷新流操作。

5、InputStream特有方法：

        int available();//返回文件中的字节个数

注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。

练习：

需求：复制一张图片F:\java_Demo\day9_28\1.BMP到F:\java_Demo\day9_28\2.bmp

[java]  view plain  copy

1. import java.io.*;    
2.     
3.     
4. class CopyPic {    
5.     public static void main(String[] args){    
6.         copyBmp();    
7.         System.out.println("复制完成");    
8.     }    
9.     
10.     public static void copyBmp() {    
11.     
12.         FileInputStream fis = null;    
13.         FileOutputStream fos = null;    
14.         try {    
15.             fis = new FileInputStream("F:\\java_Demo\\day9_28\\1.bmp");             //写入流关联文件    
16.             fos = new FileOutputStream("F:\\java_Demo\\day9_28\\2.bmp");            //读取流关联文件    
17.             byte[] copy = new byte[1024];    
18.             int len = 0;    
19.             while((len=fis.read(copy))!=-1) {    
20.             fos.write(copy,0,len);    
21.             }    
22.         }    
23.         catch (IOException e) {    
24.             e.printStackTrace();    
25.             throw new RuntimeException("复制文件异常");    
26.         }    
27.         finally {    
28.             try {    
29.                 if(fis!=null) fis.close();    
30.             }    
31.             catch (IOException e) {    
32.                 e.printStackTrace();    
33.                 throw new RuntimeException("读取流");    
34.             }    
35.         }    
36.             
37.     }    
38.     
39. }    

2. 字节流缓冲区

* 字节流缓冲区跟字符流缓冲区一样，也是为了提高效率。

注意事项：

1. read()：会将字节byte()提升为int型值

2. write()：会将int类型转换为byte()类型，保留最后的8位。

练习：

1.复制MP3文件   1.MP3 -->  2.MP3

2.自己写一个MyBufferedInputStream缓冲类，提升复制速度

代码：

[java]  view plain  copy

1. import java.io.*;    
2.     
3.     
4. //自己的BufferedInputStream    
5. class MyBufferedInputStream  {    
6.     private InputStream in;                         //定义一个流对象    
7.     private byte [] buf = new byte[1024*4];    
8.     private int count = 0,pos = 0;    
9.     public MyBufferedInputStream(InputStream in){    
10.         this.in = in;    
11.     }    
12.     
13.     public  int MyRead() throws IOException{    
14.         if(count==0) {              //当数组里的数据为空时候，读入数据    
15.             count = in.read(buf);    
16.             pos = 0;    
17.             byte b = buf[pos];    
18.             count--;    
19.             pos++;    
20.             return b&255;       //提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111    
21.         }    
22.         else if(count > 0) {    
23.             byte b = buf[pos];    
24.             pos++;    
25.             count--;    
26.             return b&0xff;      //提升为int类型，在前面三个字节补充0。避免1111 1111 1111 1111    
27.         }    
28.         return -1;    
29.     }    
30.     
31.     public void myClose() throws IOException{    
32.         in.close();    
33.     }    
34.     
35. }    
36.     
37.     
38.     
39.     
40. class BufferedCopyDemo {    
41.     public static void main(String[] args) {    
42.         long start = System.currentTimeMillis();    
43.         copy();    
44.         long end = System.currentTimeMillis();    
45.         System.out.println("时间:"+(end-start)+"ms");    
46.     
47.     
48.         start = System.currentTimeMillis();    
49.         copy1();    
50.         end = System.currentTimeMillis();    
51.         System.out.println("时间:"+(end-start)+"ms");    
52.     }     
53.     
54. public static void copy1() {                //    应用自己的缓冲区缓冲数据    
55.     
56.         MyBufferedInputStream bis = null;    
57.         BufferedOutputStream  bos = null;    
58.         try {    
59.             bis = new MyBufferedInputStream(new FileInputStream("马旭东-入戏太深.mp3"));//匿名类，传入一个InputStream流对象    
60.             bos = new BufferedOutputStream(new FileOutputStream("3.mp3"));    
61.             int buf = 0;    
62.             while((buf=bis.MyRead())!=-1) {    
63.                 bos.write(buf);    
64.             }    
65.         }    
66.         catch (IOException e) {    
67.             e.printStackTrace();    
68.             throw new RuntimeException("复制失败");    
69.         }    
70.         finally {    
71.             try {    
72.                 if(bis!=null)  {    
73.                     bis.myClose();    
74.                     bos.close();    
75.                 }    
76.             }    
77.             catch (IOException e) {    
78.                 e.printStackTrace();    
79.             }    
80.     
81.         }    
82.     
83.     }    
84. }     

五、流操作规律

1. 键盘读取，控制台打印。

System.out: 对应的标准输出设备：控制台  //它是PrintStream对象，（PrintStream：打印流。OutputStream的子类）

System.in: 对应的标准输入设备：键盘     //它是InputStream对象

示例：

[java]  view plain  copy

1. /*================从键盘录入流，打印到控制台上================*/    
2.     public static void InOutDemo(){    
3.         //键盘的最常见的写法    
4.         BufferedReader bufr = null;    
5.         BufferedWriter bufw = null;    
6.         try {    
7.                 
8.             /*InputStream ips = System.in;        //从键盘读入输入字节流  
9.             InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流  
10.             bufr = new BufferedReader(fr);  */                 //将字符流加强，提升效率    
11.     
12.                 
13.             bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符    
14.             bufw = new BufferedWriter(new OutputStreamWriter(System.out));      //OutputStreamWriter:要写入流中的字符编码成字节    
15.             String line = null;    
16.             while((line = bufr.readLine())!=null){    
17.                 if("over".equals(line)) break;    
18.                 bufw.write(line.toUpperCase());                     //打印    
19.                 bufw.newLine();                                     //为了兼容，使用newLine()写入换行符    
20.                 bufw.flush();                                       //必须要刷新。不然不会显示    
21.             }    
22.             if(bufw!=null) {    
23.                 bufr.close();    
24.                 bufw.close();    
25.             }    
26.         }    
27.         catch (IOException e) {    
28.             e.printStackTrace();    
29.         }    
30.                 
31.             
32.     }    
33. }    

2. 整行录入

1.从键盘录入数据，并存储到文件中。

2. 我们在键盘录入的是时候，read()方法是一个一个录入的，能不能整行的录入呢？这时候我们想到了BufferedReader中ReadLine()方法。

3. 转换流

为了让字节流可以使用字符流中的方法，我们需要转换流。

 1. InputStreamReader:字节流转向字符流；

  a、获取键盘录入对象。

              InputStream in=System.in;

  b、将字节流对象转成字符流对象，使用转换流。

              InputStreamReaderisr=new InputStreamReader(in);

  c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

              BufferedReaderbr=new BufferedReader(isr);

//键盘录入最常见写法

              BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));

2.OutputStreamWriter:字符流通向字节流

示例：

[java]  view plain  copy

1. /*================把键盘录入的数据存到一个文件中==============*/    
2.     public static void inToFile() {    
3.             //键盘的最常见的写法    
4.         BufferedReader bufr = null;    
5.         BufferedWriter bufw = null;    
6.         try {    
7.                 
8.             /*InputStream ips = System.in;        //从键盘读入输入字节流  
9.             InputStreamReader fr = new InputStreamReader(ips);             //将字节流转成字符流  
10.             bufr = new BufferedReader(fr);  */                 //将字符流加强，提升效率    
11.     
12.                 
13.             bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名类。InputSteamReader:读取字节并将其解码为字符    
14.             bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));     //OutputStreamWriter:要写入流中的字符编码成字节    
15.             String line = null;    
16.             while((line = bufr.readLine())!=null){    
17.                 if("over".equals(line)) break;    
18.                 bufw.write(line.toUpperCase());                     //打印    
19.                 bufw.newLine();                                     //为了兼容，使用newLine()写入换行符    
20.                 bufw.flush();                                       //必须要刷新。不然不会显示    
21.             }    
22.             if(bufw!=null) {    
23.                 bufr.close();    
24.                 bufw.close();    
25.             }    
26.         }    
27.         catch (IOException e) {    
28.             e.printStackTrace();    
29.         }    
30.                 
31.     
32.     }    

4. 流操作基本规律

为了控制格式我将其写入了Java代码段中，如下：

示例1：文本 ~ 文本

[java]  view plain  copy

1. /*    
2. 流操作的基本规律。    
3. 一、两个明确：(明确体系)    
4. 1. 明确源和目的    
5.     源：输入流  InputStream  Reader    
6.     目的：输出流  OutputStream Writer    
7.     
8. 2. 操作的数据是否是纯文本    
9.     是： 字符流    
10.     否： 字节流    
11. 二、明确体系后要明确具体使用的对象    
12.     通过设备区分：内存，硬盘，键盘    
13.     目的设备：内存，硬盘，控制台    
14.     
15.     
16. 示例1：将一个文本文件中的数据存储到另一个文件中: 复制文件    
17.     一、明确体系    
18.         源：文件-->读取流-->(InputStream和Reader)    
19.         是否是文本：是-->Reader    
20.             
21.             
22.         目的：文件-->写入流-->(OutputStream Writer)    
23.         是否纯文本：是-->Writer    
24.         
25.     二、 明确设备    
26.         源：Reader    
27.             设备：硬盘上一个文本文件 --> 子类对象为：FileReader    
28.                 FileReader fr = new FileReader("Goods.txt");    
29.                 
30.             是否提高效率：是-->加入Reader中的缓冲区：BufferedReader    
31.                 BufferedReader bufr = new BufferedReader(fr);    
32.                     
33.         目的：Writer    
34.             设备：键盘上一个文本文件 --> 子类对象：FileWriter    
35.                 FileWriter fw = new FileWriter("goods1.txt");    
36.             是否提高效率：是-->加入Writer的缓冲区：BufferedWriter    
37.                 BufferedWriter bufw = new BufferedWriter(fw);    
38.                 
39.                 
40.                 
41. 示例2：将一个图片文件数据复制到另一个文件中：复制文件    
42.     一、明确体系    
43.         源：文件-->读取流-->(InputStream和Reader)    
44.         是否是文本：否-->InputStream    
45.             
46.             
47.         目的：文件-->写入流-->(OutputStream Writer)    
48.         是否纯文本：否-->OutputStream    
49.         
50.     二、 明确设备    
51.         源：InputStream    
52.             设备：硬盘上一个媒体文件 --> 子类对象为：FileInputStream    
53.                 FileInputStream fis = new FileInputStream("Goods.txt");    
54.                 
55.             是否提高效率：是-->加入InputStream中的缓冲区：BufferedInputStream    
56.                 BufferedInputStream bufi = new BufferedInputStream(fis);    
57.                     
58.         目的：OutputStream    
59.             设备：键盘上一个媒体文件 --> 子类对象：FileOutputStream    
60.                 FileOutputStream fos = new FileOutputStream("goods1.txt");    
61.             是否提高效率：是-->加入OutputStream的缓冲区：BufferedOutputStream    
62.                 BufferedOutputStream bufo = new BufferedOutputStream(fw);    
63.     
64. 示例3：将键盘录入的数据保存到一个文本文件中    
65.     一、明确体系    
66.         源：键盘-->读取流-->(InputStream和Reader)    
67.         是否是文本：是-->Reader    
68.             
69.             
70.         目的：文件-->写入流-->(OutputStream Writer)    
71.         是否纯文本：是-->Writer    
72.         
73.     二、 明确设备    
74.         源：InputStream    
75.             设备：键盘 --> 对用对象为：System.in --> InputStream    
76.                 为了操作方便，转成字符流Reader --> 使用Reader中的转换流：InputStreamReader    
77.                 InputStreamReader isr = new InputStreamReader(System.in);    
78.                 
79.             是否提高效率：是-->加入Reader中的缓冲区：BufferedReader    
80.                 BufferedReader bufr = new BufferedReader(isr);    
81.                     
82.         目的：Writer    
83.             设备：键盘上一个文本文件 --> 子类对象：FileWriter    
84.                 FileWriter fw = new FileWriter("goods1.txt");    
85.             是否提高效率：是-->加入Writer的缓冲区：BufferedWriter    
86.                 BufferedWriter bufw = new BufferedWriter(fw);    

5.指定编码表(转换流可以指定编码表)

要求：用UTF-8编码存储一个文本文件

[java]  view plain  copy

1. import java.io.*;    
2. public class IOStreamLaw {    
3.     
4.     /**  
5.      * @param args  
6.      */    
7.     public static void main(String[] args) throws IOException {    
8.                 //键盘的最常见写法    
9.                 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));    
10.                 BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("goods1.txt"),"UTF-8"));    
11.                 String line = null;    
12.                 while((line=bufr.readLine())!=null){    
13.                     if("over".equals(line)) break;    
14.                     bufw.write(line.toUpperCase());    
15.                     bufw.newLine();    
16.                     bufw.flush();    
17.                 }    
18.                 bufr.close();    
19.     }    
20.     
21.     
22. }    

原文： http://www.cnblogs.com/xll1025/p/6418766.html