Java学习之IO流（字符流）

字符流：顾名思义操作（读、写）字符的流对象

字符流的体系：

1、Reader
　　|--BufferedReader：从字符输入流中读取文本到缓冲区，便于有效读取字符，数组，和行
　　　　|--LineNumberReader：有行号（setLineNumber(int) 、getLineNumber()）
　　|--InputStreamReader:字节流到字符流
　　　　|--FileReader:将字符文件数据读取到缓冲区中

2、Writer
　　|--BufferedWriter：将文本写入字符输出流到缓冲区，便于有效写入单个字符，数组和字符串。
　　|--OutputStreamWriter：字符流到字节流
　　　　|--FileWriter:将缓冲区数据写入字符文件

一、FileReader和FileWriter

FileReader原理：将指定的文本文件读到内存中

FileWriter原理：把内存中字符数据写入到实体设备上（落地）。

以文本文件Copy为例：

    private static final int BUFFER_SIZE = 1024;

    public static void main(String[] args) {
    fileCopy();
    }

    private static void fileCopy() {
    FileReader fr=null;
    FileWriter fw=null;
    try {
        /*
         * 1、必须要明确被读取的文件，一定要确认文件时存在的。
         */
        fr=new FileReader("demo.txt");
        /*
         * 2、明确copy目的地
         * 如果文件不存在，自动创建 如果文件存在，会覆盖（删除再创建）
         */
        fw=new FileWriter("CopyDemo2.txt");
        
        //方式一：一个字符读取
//        int ch=0;
//        while((ch=fr.read())!=-1) {
//            fw.write(ch);
//        }
        
        //方式二：先把读取数据放入固定缓存中，然后把固定缓存写到硬盘
        //创建一个临时容器，用于缓存读取到的字符
        char[] buff=new char[BUFFER_SIZE];
        //记录读取到的字符数（其实就时向数组中装的字符个数）
        int len=0;
        while((len=fr.read(buff))!=-1) {
        /*
         * 把内容存储器读到内容全部写入到输出流中
         * 此时没有写入实体设备中（这里指硬盘）
         */
            fw.write(buff,0,len);
        }
        
    }  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();
        }
    }
 }

分析：

二、BufferedReader和BufferedWriter

BufferedReader和BufferedWriter其实就是Reader和Writer的装饰类，主要目的是为了提高读写效率。

Copy文本文件实例：

private static void fileCopy() {
    BufferedReader br = null;
    BufferedWriter bw = null;
    try {
        /*
         * 1、必须要明确被读取的文件，一定要确认文件时存在的。
         */
        FileReader fr = new FileReader("demo.txt");
        br = new BufferedReader(fr);
        /*
         * 2、明确copy目的地 如果文件不存在，自动创建 如果文件存在，会覆盖（删除再创建）
         */
        FileWriter fw = new FileWriter("CopyDemo2.txt");
        bw = new BufferedWriter(fw);
        /*
                  String len = null; 
                  while ((len = br.readLine()) != null) 
                  { 
                          bw.write(len);
                          bw.newLine();//会在文本文件最后多一个空行，没想到解决方法
                          bw.flush();//防止程序非正常停止
                  }
         */
        /*
                int len = 0;
                while ((len = br.read()) != -1) {
                bw.write(len);
                bw.flush();//防止程序非正常停止
                }
         */
        
        char[] buff=new char[1024];
        int len = 0;
        while ((len = br.read(buff)) != -1) {
        bw.write(buff,0,len);
        bw.flush();//防止程序非正常停止
        }
        

    } catch (IOException e) {
        throw new RuntimeException();
    } finally {
        if (br != null)
        try {
            br.close();
        } catch (IOException e) {

            throw new RuntimeException();
        }
        if (bw != null)
        try {
            bw.close();// 先刷新，将输出流中数据写到实体设备中，关闭系统资源，
        } catch (IOException e) {
            throw new RuntimeException();
        }
    }
 }

其原理：就是一个数组

四、自定义BufferedReader

class MyBuferedReader extends Reader {
    private Reader reader;

    MyBuferedReader(Reader reader) {
        this.reader = reader;
    }

    /*
     * 自定义缓冲区
     */
    private char[] buff = new char[1024];
    /*
     * 缓冲区数组角标
     */
    private int pos = 0;
    /*
     * 用于记录缓冲区中的数据个数 为0时，就从源中继续获取数据到缓冲区中
     */
    private int count = 0;

    public int myRead() throws IOException {
        if (count == 0) {
        count = reader.read(buff);
        pos = 0;
        }
        /*
         * 数据读完
         */
        if (count < 0) {
        return -1;
        }

        char ch = buff[pos++];
        count--;
        return ch;
    }

    public String myReadLine() throws IOException {
        StringBuilder builder = new StringBuilder();
        int ch = 0;
        while ((ch = myRead()) != -1) {
        if (ch == '
')
            continue;
        if (ch == '
')
            return builder.toString();
        builder.append((char) ch);
        }
        if (builder.length() != 0)
        return builder.toString();
        return null;
    }

    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
        //
        return 0;
    }

    @Override
    public void close() throws IOException {
        reader.close();
    }
 }