IO流：用于处理设备上数据。流：可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。流也进行分类：1：输入流（读）和输出流（写）。2：因为处理的数据不同，分为字节流和字符流。 字节流：处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。
那么为什么要有字符流呢？因为字符每个国家都不一样，所以涉及到了字符编码问题，那么GBK编码的中文用unicode编码解析是有问题的，所以需要获取中文字节数据的同时+ 指定的编码表才可以解析正确数据。为了方便于文字的解析，所以将字节流和编码表封装成对象，这个对象就是字符流。只要操作字符数据，优先考虑使用字符流体系。注意：流的操作只有两种：读和写。流的体系因为功能不同，但是有共性内容，不断抽取，形成继承体系。该体系一共有四个基类，而且都是抽象类。
字节流：InputStream  OutputStream
字符流：Reader  Writer
在这四个系统中，它们的子类，都有一个共性特点：子类名后缀都是父类名，前缀名都是这个子类的功能名称。public static void main(String[] args) throws IOException { //读、写都会发生IO异常
1：创建一个字符输出流对象，用于操作文件。该对象一建立，就必须明确数据存储位置，是一个文件。
        2：对象产生后，会在堆内存中有一个实体，同时也调用了系统底层资源，在指定的位置创建了一个存储数据的文件。
        3：如果指定位置，出现了同名文件，文件会被覆盖。
                FileWriter fw = new FileWriter("demo.txt"); // FileNotFoundException
        调用Writer类中的write方法写入字符串。字符串并未直接写入到目的地中，而是写入到了流中，(其实是写入到内存缓冲区中)。怎么把数据弄到文件中？
        fw.write("abcde");
        fw.flush(); // 刷新缓冲区，将缓冲区中的数据刷到目的地文件中。
        fw.close(); // 关闭流，其实关闭的就是java调用的系统底层资源。在关闭前，会先刷新该流。
}
close()和flush()的区别：
flush()：将缓冲区的数据刷到目的地中后，流可以使用。
close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。
io异常的处理方式：io一定要写finally；
FileWriter写入数据的细节：
1：window中的换行符：\r\n两个符号组成。 linux：\n。
2：续写数据，只要在构造函数中传入新的参数true。
3：目录分割符：window \\  /
public static void main(String[] args) {
                FileWriter fw = null;
                try {
                        fw = new FileWriter("demo.txt",true);
                        fw.write("abcde");
                }
                catch (IOException e ){
                        System.out.println(e.toString()+"....");
                }
                finally{
                        if(fw!=null)
                                try{
                                        fw.close();
                                }
                                catch (IOException e){
                                        System.out.println("close:"+e.toString());
                                }
                }
}
FileReader：使用Reader体系，读取一个文本文件中的数据。返回 -1 ，标志读到结尾。
import java.io.*;
class  FileReaderDemo {
        public static void main(String[] args) throws IOException {
                创建可以读取文本文件的流对象，FileReader让创建好的流对象和指定的文件相关联。
                FileReader fr = new FileReader("demo.txt");
                int ch = 0;
                while((ch = fr.read())!= -1) { //条件是没有读到结尾
                        System.out.println((char)ch); //调用读取流的read方法，读取一个字符。
                }
                fr.close();
        }
}
读取数据的第二种方式：第二种方式较为高效，自定义缓冲区。
import java.io.*;
class FileReaderDemo2 {
        public static void main(String[] args) throws IOException {
                FileReader fr = new FileReader("demo.txt"); //创建读取流对象和指定文件关联。
                //因为要使用read(char[])方法，将读取到字符存入数组。所以要创建一个字符数组，一般数组的长度都是1024的整数倍。
                char[] buf = new char[1024];
                int len = 0;
                while(( len=fr.read(buf)) != -1) {
                        System.out.println(new String(buf,0,len));
                }
                fr.close();
        }
}

IO中的使用到了一个设计模式：装饰设计模式。
装饰设计模式解决：对一组类进行功能的增强。包装：写一个类(包装类)对被包装对象进行包装；1、包装类和被包装对象要实现同样的接口；2、包装类要持有一个被包装对象；
3、包装类在实现接口时，大部分方法是靠调用被包装对象来实现的，对于需要修改的方法我们自己实现；
字符流：Reader：用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。
     |---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
        |---LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。
     |---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
        |---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
     |---CharArrayReader：
     |---StringReader：
Writer：写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。
     |---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
     |---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
        |---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。
     |---PrintWriter：
     |---CharArrayWriter：
     |---StringWriter：
字节流：
InputStream：是表示字节输入流的所有类的超类。
     |--- FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。
     |--- FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。
        |--- BufferedInputStream：该类实现缓冲的输入流。
        |--- Stream：
     |--- ObjectInputStream：
     |--- PipedInputStream：
OutputStream：此抽象类是表示输出字节流的所有类的超类。
     |--- FileOutputStream：文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。
     |--- FilterOutputStream：此类是过滤输出流的所有类的超类。
        |--- BufferedOutputStream：该类实现缓冲的输出流。
        |--- PrintStream：
        |--- DataOutputStream：
     |--- ObjectOutputStream：
     |--- PipedOutputStream：
缓冲区是提高效率用的，给谁提高呢？
BufferedWriter：是给字符输出流提高效率用的，那就意味着，缓冲区对象建立时，必须要先有流对象。明确要提高具体的流对象的效率。
        FileWriter fw = new FileWriter("bufdemo.txt");
        BufferedWriter bufw = new BufferedWriter(fw);//让缓冲区和指定流相关联。
        for(int x=0; x<4; x++){
                bufw.write(x+"abc");
                bufw.newLine(); //写入一个换行符，这个换行符可以依据平台的不同写入不同的换行符。
                bufw.flush();//对缓冲区进行刷新，可以让数据到目的地中。
        }
        bufw.close();//关闭缓冲区，其实就是在关闭具体的流。
BufferedReader：
        FileReader fr = new FileReader("bufdemo.txt");
        BufferedReader bufr  = new BufferedReader(fr);
        String line = null;
        while((line=bufr.readLine())!=null){  //readLine方法返回的时候是不带换行符的。
                System.out.println(line);
        }
        bufr.close();
//记住，只要一读取键盘录入，就用这句话。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));//输出到控制台
String line = null;
while((line=bufr.readLine())!=null){
        if("over".equals(line))
                break;
        bufw.write(line.toUpperCase());//将输入的字符转成大写字符输出
        bufw.newLine();
        bufw.flush();
        }
bufw.close();
bufr.close();流对象：其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的操作规律。
流的操作规律：1，明确源和目的。数据源：就是需要读取，可以使用两个体系：InputStream、Reader；数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；2，操作的数据是否是纯文本数据？
        如果是：数据源：Reader
                    数据汇：Writer
        如果不是：数据源：InputStream
                      数据汇：OutputStream
3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？
        明确操作的数据设备。
        数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)
        数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。
4，需要在基本操作上附加其他功能吗？比如缓冲。
        如果需要就进行装饰。
转换流特有功能：转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。
转换流的最强功能就是基于 字节流 + 编码表 。没有转换，没有字符流。
发现转换流有一个子类就是操作文件的字符流对象：
InputStreamReader
        |--FileReader
OutputStreamWriter
        |--FileWrier
想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。
但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。
FileReader fr = new FileReader("a.txt");
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"gbk");
以上两句代码功能一致，
如果仅仅使用平台默认码表，就使用FileReader fr = new FileReader("a.txt"); //因为简化。
如果需要制定码表，必须用转换流。转换流 = 字节流+编码表。转换流的子类File = 字节流 + 默认编码表。凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

厉害！！！！！！

写的不错！！！

谢谢楼主分享