Java总结(9) IO(一)

流的概念

计算机当中的流

计算机中经常出现的一个词就是IO流，IO流为什么叫IO流呢，IO就是 input output 的简称，先说 IO，从计算机体系结构上来说，计算机的主板的许多芯片中有个特别的东西叫 IO 芯片(intel 的架构)，或者计算机的 cpu 中集成有 IO 引脚(arm 架构、单片机之类)。这个东西主要作用就是计算机芯片和其他设备交换数据用的，特别指计算机内存和其他外围设备交换数据时使用的。再说流，stream 是 IO 设备读写的一种方法，对比内存中数据通常的读写方法，这种数据读写方法叫做流式读写，回想我们用c语言读写内存中的数据，我们都是一个单位一个单位读写的，这个单位是数据线的宽度决定的，比如 8 bits、32 bit、 64 bits。而流式方法，好比水流，我们每次读写的数据的大小是可以指定的，然后它会自动分多次有秩序地持续完成数据交换，这里主要跟硬件的缓冲区和 DMA 有关系。IO 都有流的概念，流式读写的特征跟水流一样是自动的多次读一个资源的数据到内存，多次写内存的数据到资源，流解决了两个速度不同的存储设备之间传输数据的问题，速度慢的外设先把数据放到缓冲区，然后集中一小段时间占用总线把这些数据传给内存，其他时间内存和其他设备交换数据，或者内存先把数据传送给外设缓冲区，缓冲区再慢慢把数据写入设备对应位置。流式读写可以分为 节点流和处理流，字节流和字符流，输入流和输出流。
IO中的流就相当与我们日常生活中的管道,我们通过管道来把水引到用户,通过管道把石油输送到大罐.同样,我们利用流来从硬盘的文件中读数据到你的程序中,利用流来写数据到硬盘的文件，文件流 缓冲流 数据流 转换流 Print流 Object流正是为了实现这些功能的不同的类,他们具体包含了实现这些功能的方法，但如果每次都要从硬盘读取一个字节数据或写1个字节数据到硬盘,那就对硬盘损害太大了,比如电驴就损害硬盘.解决办法:在内存中建立一个缓冲区(buffer),读一次硬盘就把缓冲区装满,然后你就可以从缓冲区读取数据,写数据的时候,先在内存中把数据写到缓冲区,写满,然后把数据一次性地从缓冲区写到硬盘.这样对硬盘的访问次数大大减少了.缓存要交换的数据:就是读数据的时候把数据一次性读到缓冲区和写数据的时候先把数据写到缓冲区的意思，buffer是在内存中是通过字节数组实现的。

Java中的IO流

所以在 Java 中 IO流 是一组有序的数据序列，以 程序 为中心，根据数据流的方向，可分为输入流和输出流两种 IO 流，这相当于在程序和其他设备之间的一条通道，程序可以使用这条通道从数据源输入数据，再把数据输出到目的地，完成把源地址中的字节序列送到目的地的过程。虽然程序 IO流 经常和磁盘文件存取有关，但是程序的源和目的地也可以是键盘、鼠标、内存、显示屏、网络设备、硬盘 等等。
总结起来就是：流是指 自动有序的完成数据交换，IO 是指我们的程序和其他设备之间数据交换，IO流就是指我们的程序和其他设备之间自动有序的完成数据交换。

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

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 = 字节流 + 默认编码表。
凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。