概述：

1、IO流：即Input Output的缩写。

2、特点：

1）IO流用来处理设备间的数据传输。

2）Java对数据的操作是通过流的方式。

3）Java用于操作流的对象都在IO包中。

4）流按操作数据分为两种：字节流和字符流。

5）流按流向分为：输入流和输出流。

注意：流只能操作数据，而不能操作文件。

3、IO流的常用基类：

1）字节流的抽象基流：InputStream和OutputStream

2）字符流的抽象基流：Reader和Writer

注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如InputStream子类FileInputStream和Reader子类FileReader

第一节   字符流
一、简述：

1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。

2、字符流只用于处理文字数据，而字节流可以处理媒体数据。

3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。专门用于操作文件的Writer子类对象：FileWriter   --->  后缀名为父类名，前缀名为流对象的功能。

二、字符流的读写

1、写入字符流：

1）创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步就是在明确数据要存放的目的地。

2）调用write(String s)方法，将字符串写入到流中。

3）调用flush()方法，刷新该流的缓冲，将数据刷新到目的地中。

4）调用close()方法，是关闭流资源。但是关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。

注：

--->close()和flush()区别：flush()刷新后，流可以继续使用；而close()刷新后，将会关闭流，不可再写入字符流。

--->其实java自身不能写入数据，而是调用系统内部方式完成数据的书写，使用系统资源后，一定要关闭资源。

--->数据的续写是通过构造函数 FileWriter(String s,boolean append)，根据给定文件名及指示是否附加写入数据的boolean值来构造FileWriter对象。

2、读取字符流：

1）创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，若不存在，将会发生异常FileNotFoundException。

2）调用读取流对象的read()方法。read()：一次读一个字符，且会继续往下读。

      第一种方式：读取单个字符。第二种方式：通过字符数组进行读取。

3）读取后要将流资源关闭。


示例：

[java] view plaincopyprint?
<span style="font-family:Arial;font-size:10px;">import java.io.*;  
class IODemo{  
    public static void main(String[] args){  
        FileWriter fw =null;  
        FileReader fr = null;  
        //检测异常  
        try{  
            //创建读写对象，并指定目的地  
            fw = new FileWriter("Demo.txt");  
            fr = new FileReader("Demo.txt");  
            //将数据写入到指定文件中  
            for(int i=0;i<5;i++){  
                fw.write("abcde" + i + "\r\n");  
                fw.flush();  
            }  
            //从指定文件中读取数据  
            int len = 0;  
            char[] ch = new char[1024];  
            while((len=fr.read(ch))!=-1){  
                System.out.println(new String(ch,0,len));  
            }  
        }  
        //捕获异常  
        catch (IOException e){  
            throw new RuntimeException("读写文件失败");  
        }  
        //最终关闭两个流资源  
        finally{  
            if(fw!=null){  
                try{  
                    fw.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("关闭流资源失败。");  
                }  
            }  
            if(fr!=null){  
                try{  
                    fr.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("读取流资源失败。");  
                }  
            }  
        }  
    }  
}  
</span>  

二、文件的拷贝：

原理：其实就是将一个磁盘下的文件数据存储到另一个磁盘的一个文件中
步骤：
1、在D盘上创建一个文件，用于存储E盘文件中的数据
2、定义读取流和E盘文件关联
3、通过不断读写完成数据存储
方式一：读取一个字符，存入一个字符
方式二：先将读取的数据存入到内存中，再将存入的字符取出写入D盘
4、关闭流资源：输入流资源和输出流资源。
示意图：


示例：

[java] view plaincopyprint?
<span style="font-family:Arial;">import java.io.*;  
class CopyDemo  
{  
    public static void main(String [] args)  
    {  
        FileReader fr = null;  
        FileWriter fw = null;  
        try{  
            fr = new FileReader("E:\\Dmeo.txt");  
            fw = new FileWriter("D:\\Dmeo.txt");  
            char[] ch = new char[1024];  
            int len = 0;  
            //用ch将读取的文件和写入的文件关联起来  
            while((len=fr.read(ch))!=-1)  
            {  
                fw.write(ch,0,ch.length);  
            }  
        }  
        catch (IOException e){  
            throw new RuntimeException("文件读写失败");  
        }  
        finally{  
            if(fr!=null){  
                try{  
                    fr.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("读取流资源关闭失败。");  
                }  
            }  
            if(fw!=null){  
                try{  
                    fw.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("写入流资源关闭失败。");  
                }  
            }  
        }  
    }  
}</span>  


三、BufferedWriter和BufferedReader：字符流缓冲区

1、缓冲区的出现：提高了流的读写效率，所以在缓冲区创建前，要先创建流对象，即先将流对象初始化到构造函数中。

2、缓冲技术原理：此对象中封装了数组，将数据存入，在一次性取出。

3、写入流缓冲区BufferedWriter的步骤：

1）创建一个字符写入流对象

2）为提高字符写入流效率，加入缓冲技术，只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

      注意，只要用到缓冲去就需要刷新。

3）其实关闭缓冲区就是在关闭缓冲区中的流对象。

－－－＞该缓冲区中提供了一个跨平台的换行符：newLine()。

4、读取流缓冲区BufferedReader的步骤：
1）创建一个读取流对象和文件关联

2）为提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数。

3）该缓冲区提供了一个一次读一行的方法readLine()，方便与对文本数据的获取，当返回null时，表示读到文件末尾。

      readLine()方法返回的时只返回回车符之前的数据内容，并不返回回车符，即读取的内容中不包含任何行终止符（回车符和换行符）。

--->readLine()方法原理：无论是读一行，或读取多个字符，其实最终都是在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个。

示意图：


5、使用缓冲技术拷贝文件，提高效率：

示例：

[java] view plaincopyprint?
<span style="font-family:Arial;">import java.io.*;  
class CopyBufferedDemo{  
    public static void main(String[] args) {  
        BufferedReader bufr = null;  
        BufferedWriter bufw = null;  
        try{  
            //创建缓冲区，将读写流对象作为参数传入  
            bufr = new BufferedReader(new FileReader("D:\\JAVA\\IO\\buffered\\myJava.txt"));  
            bufw = new BufferedWriter(new FileWriter("D:\\JAVA\\IO\\文件拷贝\\myJava.txt"));  
            //定义字符串，通过readLine一次读一行，并存入缓冲区  
            String line = null;  
            while((line=bufr.readLine())!=null)  
            {  
                //将读取到缓冲区的数据通过line存入写入流中  
                bufw.write(line);  
                //换行符方法  
                bufw.newLine();  
                //将数据刷新到指定文件中  
                bufw.flush();  
            }  
        }  
        catch (IOException e){  
            throw new RuntimeException("读写文件失败。");  
        }  
        finally{  
            if(bufr!=null){  
                try{  
                    bufr.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("读取流资源关闭失败。");  
                }  
            }  
            if(bufw!=null){  
                try{  
                    bufw.close();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("写入流资源关闭失败。");  
                }  
            }  
        }  
    }  
}  
</span>  

6、自定义BufferedReader：

原理：可根据BufferedReader类中特有发那个发readLine()的原理，自定义一个类中包含相同功能的方法

步骤：a.初始化自定义的类，加入流对象。

            b.定义一个临时容器，原BufferedReader封装的是字符数组，此类中可定义一个StringBuilder的容器，最终可实现字符串的提取。

[java] view plaincopyprint?
import java.io.*;  
//自定义一个功能与BufferedReader相似的类，继承Reader  
class MyBufferedReader extends Reader  
{  
    //定义变量，用于全局  
    private Reader r;  
    //构造函数，传入读取流对象  
    MyBufferedReader(Reader r)  
    {  
        this.r = r;  
    }  
    //复写readLine放，并将异常抛出，有调用者处理  
    public String MyReadLine()throws IOException  
    {  
        //定义存储字符串的容器  
        StringBuilder sb = new StringBuilder();  
        int ch = 0;  
        //read()方法遍历文件，当达末尾时判断是否为-1结束循环  
        while((ch=r.read())!=-1)  
        {  
            //判断是否有行终止符，有则不存入  
            if(ch=='\r')  
                continue;  
            //当读到结尾，需要将缓冲区中存放的数据变为字符串返回  
            if(ch=='\n')  
                return sb.toString();  
            else  
                //将读取的字符存入容器  
                sb.append((char)ch);  
        }  
        //对于最后一行没有终止符的情况，需要将读取到的加入容器中  
        if(sb.length()!=0)  
            return sb.toString();  
        //读到结尾处，返回null  
        return null;  
    }  
    /*
    覆盖抽象方法:
    */  
    public int read(char[] cbuf,int off,int len)throws IOException  
    {  
        return r.read(cbuf,off,len);  
    }  
    //覆盖close方法  
    public void close()throws IOException  
    {  
        r.close();  
    }  
    //创建自定义close方法  
    public void MyClose()throws IOException  
    {  
        r.close();  
    }  
}  
//测试  
class MyBufferedDemo{  
    public static void main(String [] args){  
        MyBufferedReader mbr = null;  
        //检测异常  
        try{  
            mbr = new MyBufferedReader(new FileReader("Demo.txt"));  
            String line = null;  
            //遍历文件，读取数据  
            while ((line=mbr.MyReadLine())!=null){  
                System.out.println(line);  
            }  
        }  
        //捕获异常  
        catch (IOException e){  
            throw new RuntimeException("读取文件失败。");  
        }  
        //最终关闭资源  
        finally{  
            if(mbr!=null){  
                try{  
                    mbr.MyClose();  
                }  
                catch (IOException e){  
                    throw new RuntimeException("读取流关闭失败。");  
                }  
            }  
        }  
    }  
}  

7、LineNumberReader

在BufferedReader中有个直接的子类LineNumberReader，其中有特有的方法获取和设置行号：
setLineNumber()和getLineNumber()

示例：

[java] view plaincopyprint?
......  
try  
{  
    fr = new FileReader("myJava.txt");  
    lnr = new LineNumberReader(fr);  
    lnr.setLineNumber(100);  
    String line = null;  
    while((line=lnr.readLine())!=null)  
    {  
        System.out.println(lnr.getLineNumber() + ":  " + line);  
    }  
}  
......  

通过这个例子，就可以引出装饰设计模式

四、装饰设计模式：

1、简述：当想对已有对象进行功能增强是，可定义类：将已有对象传入，基于已有对象的功能，并提供加强功能，那么自定义的该类称之为装饰类。即对原有类进行了优化。

2、特点：装饰类通常都会通过构造方法接收被装饰的对象，并基于被装饰的对i型那个的功能提供更强的功能。

3、装饰和继承的区别：

1）装饰模式比继承要灵活，通过避免了继承体系的臃肿，且降低了类与类间的关系。

2）装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能，所以装饰类和被装饰的类通常都是属于一个体系。

3）从继承结构转为组合结构。

注：在定义类的时候，不要以继承为主；可通过装饰设计模式进行增强类功能。灵活性较强，当装饰类中的功能不适合，可再使用被装饰类的功能。

        要继承相应的父类，就需要将所有的抽象方法实现，或交给子类实现。

示例：其中MyBufferedReader的例子就是最好的装饰设计模式的例子。

强！{:3_46:}

谢谢分享

强大  谢谢分享

太多了.....

谢谢楼主分享

啥也不说了 楼主强大

太深了！！！

         赞一个