JAVA--IO(后)

字符流：
     字符输入流
         Reader
     字符输出流
         Writer


Writer
     OutputStreamWriter: 字符输出流 是以字节流加上编码表得到的一个转换流，后期写数据的时候可以根据自己指定的编码进行写入
     public OutputStreamWriter(OutputStream out)
     创建一个使用默认字符编码的OutputStreamWriter。根据默认的编码用字符作为桥梁将字节流的数据转换为字符流
     public OutputStreamWriter(OutputStream out,String charsetName)
     根据指定的编码用字符作为桥梁将字节流的数据转换为字符流

     把字节流转化字符流

     字符流 = 字节流 + 编码表

public class OutputStreamWriterDemo1 {
    public static void main(String[] args) throws Exception {
        //1、创建字符输出流对象
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("aaa.txt"));
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("bbb.txt"),"GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("ccc.txt"),"GBK");

        osw.write("中国");

        //释放资源
        osw.close();


    }
}

Reader
    InputStreamReader: 字符输入流
    public InputStreamReader(InputStream in)
    读取数据，根据默认的编码用字符作为桥梁将字节流的数据转换为字符流
    public InputStreamReader(InputStream in,String charsetName)
    读取数据，根据指定的编码用字符作为桥梁将字节流的数据转换为字符流

public class InputStreamReaderDemo1 {
    public static void main(String[] args) throws Exception {
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("bbb.txt"));
        InputStreamReader isr = new InputStreamReader(new FileInputStream("ccc.txt"),"GBK");

        //一次读取一个字符
        int c = 0;
        while ((c=isr.read())!=-1){
            System.out.print((char) c);
        }

        //释放资源
        isr.close();

    }
}

OutputStreamWriter写数据的方法：
     public void write(int c)
     public void write(char[] cbuf)
     public void write(char[] cbuf,int off,int len)
     public void write(String str)
     public void write(String str,int off,int len)

flush()和close()的区别：
 1、调用完flush()后，流对象并没有关闭，还能继续写数据。
 2、调用完close()后，流对象关闭了，后续无法再通过这个对象写数据。

public class OutputStreamWriterDemo2 {
    public static void main(String[] args) throws Exception {
        //1、创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("ddd.txt"));

        //写数据
        //public void write(int c) 写一个字符
//        osw.write(99);
//        osw.write('a');

        //现象，我们在把close去掉之后，发现数据没有写入到文件中
        //原因
        //文件实际上在硬盘存储的是字节，需要手动转换一下进行存储
        //void flush()
        //刷新流。
//        osw.flush();
//        osw.write();

        //public void write(char[] cbuf) 写一个字符数组
        char[] chars = {'a','b','c','d','e'};
//        osw.write(chars);

        //public void write(char[] cbuf,int off,int len) 写字符数组的一部分
//        osw.write(chars,1,3);

        //public void write(String str)
//        osw.write("小米和华为真强");

        //public void write(String str,int off,int len) 写字符串的一部分
        osw.write("小米和华为真强",3,2);

        //释放资源
        osw.close(); //包含了flush()操作

//        osw.write();
    }
}

        InputStreamReader:字符输入流
            读取数据的方法：
                public int read()
                public int read(char[] cbuf)

public class InputStreamReaderDemo2 {
    public static void main(String[] args) throws Exception {
        //1、创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("e.txt"));

        //一次只读一个字符
        //字符读取，如果已经达到流的结尾，则为-1
//        int i = 0;
//        while ((i=isr.read())!=-1){
//            System.out.print((char) i);
//        }
        //一次读取一个字符数组
        //读取的字符数，如果已经达到流的结尾，则为-1
        char[] chars = new char[1024];
        int length = 0;
        while ((length = isr.read(chars)) != -1) {
            System.out.print(new String(chars, 0, length));
        }
        //释放资源
        isr.close();

    }
}

由于我们常见的操作都是使用本地默认的编码，我们基本上使用的时候不去指定编码
但是呢，我觉得创建字符转换流对象的时候，名字有点长，所以Java提供了子类给我们使用
字符流 = 字节流 + 编码表
OutputStreamWriter = FileOutputStream + 编码表
InputStreamReader = FileInputStream + 编码表

把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：
    a.txt -- 读取数据 -- 字符输入流 -- Reader -- InputStreamReader -- FileReader
目的地：
    b.txt -- 写出数据 -- 字符输出流 -- Writer -- OutputStreamWriter -- FileWriter

public class CopyFileDemo3 {
    public static void main(String[] args) throws Exception {
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));

        //FileReader(String fileName)
        //创建一个新的 FileReader ，给定要读取的文件的名称。
        FileReader fr = new FileReader("a.txt");
        //创建字符输出流对象
        //FileWriter(String fileName)
        //构造一个给定文件名的FileWriter对象。
        FileWriter fw = new FileWriter("b.txt");

        //一次读写一个字符
//        int ch = 0;
//        while ((ch=fr.read())!=-1){
//            fw.write(ch);
//            fw.flush();
//        }

        //一次读写一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while ((length=fr.read(chars))!=-1){
            fw.write(chars,0,length);
            fw.flush();
        }


        //释放资源
        fw.close();
        fr.close();

    }
}

字符流为了高效读写，也提供了对应的字符缓冲流
字符缓冲输出流：BufferedWriter
字符缓冲输入流: BufferedReader



BufferedWriter:
    将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。
    可以指定缓冲区大小，或者可以接受默认大小。 默认值足够大，可用于大多数用途。

BufferedWriter(Writer out)
    创建使用默认大小的输出缓冲区的缓冲字符输出流。

public class BufferedWriterDemo1 {
    public static void main(String[] args) throws Exception {
//        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a2.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter("a2.txt"));

        bw.write("hello");
        bw.write("\r\n");
        bw.write("world");
        bw.write("\r\n");
        bw.write("java");
        bw.write("\r\n");
        bw.write("hadoop");

        bw.flush();

        //释放资源
        bw.close();

    }
}

BufferedReader: 字符缓冲输入流
从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

BufferedReader(Reader in)
创建使用默认大小的输入缓冲区的缓冲字符输入流。

public class BufferedReaderDEmo1 {
    public static void main(String[] args) throws Exception {
//        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));

        //1、一次读取一个字符
//        int ch = 0;
//        while ((ch=br.read())!=-1){
//            System.out.print((char) ch);
//        }

        //2、一次读取一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while ((length=br.read(chars))!=-1){
            System.out.println(new String(chars,0,length));
        }

        //释放资源
        br.close();


    }
}

字符缓冲流的特殊读写方法：
BufferedWriter:
     void newLine()
     写一行行分隔符。 行分隔符字符串由系统属性line.separator定义，并不一定是单个换行符（'\ n'）字符。

BufferedReader:
     public String readLine()
     读一行文字。 一行被视为由换行符（'\ n'），回车符（'\ r'）中的任何一个或随后的换行符终止。

public class BufferedDemo1 {
    public static void main(String[] args) {
        try {
            write();
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            read();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void read() throws Exception{
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("a.txt"));
        //public String readLine() 一次读取一行文字
        //包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为null
//        String s = br.readLine();
//        System.out.println(s);
//        String s2 = br.readLine();
//        System.out.println(s2);

        //用循环读取
        String line = null;
        while ((line = br.readLine())!=null){
            System.out.println(line);
        }

        //释放资源
        br.close();

    }


    public static void write() throws Exception{
        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("a3.txt"));
        for(int i=1;i<=10;i++){
            bw.write("大数据"+i);
//            bw.write("\r\n");
            bw.newLine(); //根据系统写入换行符
            bw.flush();
        }

        //释放资源
        bw.close();
    }
}