IO流学习笔记（一）之FileWriter与FileReader

IO流

IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中
流按照操作数据分为两种：字节流和字符流
流按流向分为：输入流和输出流

输入流和输出流是相对于内存设备而言
因为内存速度快，程序在内存中运行，数据从外设（硬盘）读取到内存中为输入，数据由内存到外设（硬盘）为输出

字符流的由来：
字节流可以处理所有数据，最早是没有字符流的，但是由于不同语言产生了多张码表（用于将其语言转为计算机语言即01码，如ascll，GBK等），由于多张码表的麻烦，国际组织便产生一张通用的码表Unicode码表，可以识别中英文等，Java中内置Unicode码表。其特点是无论什么字符都用两个字节表示，导致同一个中文在GBK和Unicode码表中对应的数字结果不同（因为对于编写程序选择不同编码方式会产生乱码），将（字节流+编码表）的组合方式封装为字符流。
简要来说：字节流读取文字字节数据后，不直接操作，而是先查指定的编码表，获取对应的文字，再对这个文字进行操作。简单来说，就是字节流+编码表。

分类：
字节流的抽象基类：InputStream,OutputStream
字符流的抽象基类：Reader,Writer
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀，如InputStream的子类FileInputStream，Reader的子类FileReader
命名方式可以看作：该对象的功能+以父类名作为后缀

操作文字数据建议优先考虑字符流，而且要将数据从内存写到硬盘上，要使用字符流中的输出流Writer类，将数据从内存写到硬盘上，硬盘上的数据基本体现是文件，希望找到一个可以操作文件的Writer,即FileWriter

FileWriter

既然是往一个文件中写入文字数据，那么在创建对象时，必须明确该文件（用于存储数据的目的地），如果文件不存在，则会自动创建；如果文件存在，则会被覆盖，由于文件路径可能是非法路径，会导致IO异常，因此在方法处抛出，即throws IOException

构造函数：

FileWriter(String fileName):根据给定的文件名构造一个FileWriter对象

FileWriter(String fileName，boolean append)：根据给定的文件名以及指示是否附加（续写）写入数据的boolean值来构造FileWriter对象，构造函数中加入true，可以实现对文件进行续写，不然第二次运行程序会删除原有内容，续写，即可以再次运行写入时，是在原有的基础上基础写入，原内容是保存的

public class FileWriterDemo {
    /*
    平台独立的换行符。
    */
    public static final String LS = System.getProperty("line.separator");
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("demo.txt");//new对象时其实已经开始对硬盘进行操作
        fw.write("abcde\r\nhahaha");
        fw.write("abcde"+ LS+"nhahaha");//无论什么系统都可以实现换行
        fw.close();
    }
}

flush()与close()区别：
flush()方法：刷新该流的缓冲，如果该流已保存缓冲区中各种write()方法的所有字符，则立即将它们写入预期目标。然后，
如果该目标是另一个字符或字节流，则将其刷新。因此，一次flush()调用将刷新Writer和OutputStream链中的所有缓冲区，因此上述写入也可以：

fw.write("abcde\r\nhahaha");
fw.write("abcde"+ LS+"nhahaha");
fw.flush();

close()关闭流，关闭资源。在关闭前会先调用flush刷新缓冲中的数据到目的地

与flush()的区别：flush可以使用多次，不断写入不断刷新即可，而close只可以使用一次，关闭之后，不可以进行流操作。 形象比喻：在一个文档中写数据，每保存一次就相当于进行一次flush（不保存并没有写入硬盘）；如果一直写不保存，写完之后关闭，进行一次保存，写入硬盘，相当于close，再打开文件操作时，是另一个流。

换行问题：

fw.write("abcde\nhahaha")

并不能实现换行，windows中的换行是\r，unix中换行是\n，因此需要fw.write("abcde\r\nhahaha");，还有一种与系统无关的换行方式：

public static final String LS = System.getProperty("line.separator");

IO异常的处理方式

public class IOExceptionDemo {
    public static final String LS = " " + System.getProperty("line.separator");
    public static void main(String[] args) {
        /*
        流对象异常的处理方式是在try块外创建引用变量，在try块里面进行对象的初始化
         */
        FileWriter fw = null;
        try {
            fw = new FileWriter("demo.txt");
            fw.write("abcde"+ LS +"nhahaha");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //因为在之前创建fw对象时，如果是无效的路径，无法创建fw对象，此处可能空指针异常NullPointerException
            if (fw!=null){
                try {
                    fw.close();//关闭资源的异常是由底层造成的
                } catch (IOException e) {
                    throw new RuntimeException("关闭失败");
                }
            }
        }
    }
}

FileReader

进行读取有两种方式，一种是read()方法，一种是read(char[] cbuf)方法，如下将分别介绍两种方法：

read()方法

public int read() throws IOException:
读取单个字符，在字符可用，发生I/O错误或者已到达流的末尾前，此方法一直阻塞
返回：作为整数读取的字符，范围在0到65535之间，如果已到达流的末尾，则返回-1

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //1.创建读取字符数据的流对象
        /*
        构造函数其一：
        FileReader(String fileName):在给定从中读取数据的文件名的情况下创建一个新的FileReader
        在创建读取流对象时，必须要明确读取的文件，一定要确定该文件是存在的
        用一个读取流关联一个已经存在的文件
         */
        FileReader fr = new FileReader("demo.txt");//与文件关联
        //用Reader中的read方法读取字符,此时文本中的数据是“ab”，硬盘中存储的是二进制，例如a对应的是97，b对应的是98
        int ch = fr.read();
        System.out.println(ch);
        System.out.println((char)ch);
        int ch1 = fr.read();
        System.out.println(ch1);
        int ch2 = fr.read();
        System.out.println(ch2);//到达结尾如扔继续读取，仍是-1
        //图例假设结束标记是#，当读取到结束标记时，JVM为了表明读到了结尾，用-1表示
    }
}

运行结果：

原理：

基于如上原理可以如下进行连续读取,即连续读取数据的第一种方式，一次读一个

int ch = 0;
while((ch=fr.read())!=-1){
    System.out.println((char)ch);//转为字符进行输出
}

read(char[] cbuf)方法

public int read(char[] cbuf) throws IOException:
将字符读入数组。在某个输入可用，发生I/O错误或者已到达流的末尾前，此方法一直阻塞
参数：
cbuf-目标缓冲区
返回：
读取的字符数（不同于read()方法,read()方法返回的是读到的字符），如果已到达流的末尾，则返回-1
不同于read(),read(char[] cbuf)是每读取一个便将其存与数组cbuf中

public class FileReaderDemo2 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("demo.txt");//与文件关联   
        char[] buf = new char[3];//txt文本中是“abcde"
        int num = fr.read(buf);//将读到的字符存储到数组中，此时内容abc
        System.out.println(num+":"+new String(buf));
        int num1 = fr.read(buf);//将读到的字符存储到数组中，此时内容dec
        System.out.println(num1+":"+new String(buf));
        int num2 = fr.read(buf);//将读到的字符存储到数组中，此时内容dec，因为已经到达末尾，并没有读取到新字符
        System.out.println(num2+":"+new String(buf));
        fr.close();
    }
}

原理：

基于第二种读取方式的连续读取：

int len = 0;
while((len=fr.read(buf))!=-1){
    System.out.println(new String(buf,0,len));
}

两种读取方式哪种好?

第二种读取所需的循环次数少，效率高，第一种方式有多少个字符就需要循环多少次

复制文本文件

public class CopyText {
    private static final int BUFFER_SIZE = 1024;
    public static void main(String[] args){
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("demo.text");
            fw = new FileWriter("test.text");
            //创建一个容器，用于读取缓冲字符
            char[] buf = new char[BUFFER_SIZE];
            int len = 0;
            while ((len=fr.read(buf))!=-1){
                fw.write(buf,0,len);
            }
        }catch (Exception e){
            throw new RuntimeException("读写失败");
        }finally {
            if (fr!=null)
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();//如果是图形化界面，这些语句实际就是弹出的对话框
                }
            if (fw!=null)
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

两个流（输入流fr与输出流fw）原本是没有关系的，想要使两者能够进行数据传输，需要通过一个“中转”即上述的数组容器