IO流

1.字符流

01.字符流 = 字节流 +编码表
  a：输入流
    OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
    OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流 把字节流转换为字符流。

   public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
         "osw.txt")); // 默认GBK
        // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
        // "osw.txt"), "GBK"); // 指定GBK
        //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "osw.txt"), "UTF-8"); // 指定UTF-8
        // 写数据
        osw.write("中国");

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

   b.输出流
    InputStreamReader(InputStream in):用默认的编码读取数据
    InputStreamReader(InputStream in,String charsetName):用指定的编码读取数据

  public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        // InputStreamReader isr = new InputStreamReader(new FileInputStream(
        // "osw.txt"));

        // InputStreamReader isr = new InputStreamReader(new FileInputStream(
        // "osw.txt"), "GBK");

        InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"), "UTF-8");

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

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

  c.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):写一个字符串的一部分
  面试题：close()和flush()的区别?
  A:close()关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。
  B:flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "osw2.txt"));

        // 写数据
        // public void write(int c):写一个字符
        // osw.write('a');
        // osw.write(97);
        // 为什么数据没有进去呢?
        // 原因是：字符 = 2字节
        // 文件中数据存储的基本单位是字节。
        // void flush()

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

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

        // public void write(String str):写一个字符串
        // osw.write("我爱林青霞");

        // public void write(String str,int off,int len):写一个字符串的一部分
        osw.write("我爱林青霞", 2, 3);

        // 刷新缓冲区
        osw.flush();
        // osw.write("我爱林青霞", 2, 3);

        // 释放资源
        osw.close();
        // java.io.IOException: Stream closed
        // osw.write("我爱林青霞", 2, 3);
    }
}

 d.InputStreamReader的方法：
   int read():一次读取一个字符
   int read(char[] chs):一次读取一个字符数组

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "a.txt"));
        // 读取数据

        /*int ch=0;
        while ((ch = isr.read()) != -1)// 一次读取一个字符
        {
            System.err.println((char) ch);
        }*/
        char[] chs=new char[1024];
        int len=0;
        while((len=isr.read(chs))!=-1){//一次读取一个字符数组
            System.out.println(new String(chs,0,len));

        }
        isr.close();


    }

}

  案例：需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

    public class Demo01 {
    public static void main(String[] args) throws IOException {
        //封装数据源
        InputStreamReader isr=new InputStreamReader(new FileInputStream("a.txt"));
        //封装目的地
        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("b.txt") );
        /*int ch=0;
        while((ch=isr.read())!=0){
            osw.write(ch);
        }*/
        int len=0;
        char[] chs=new char[1024];
        while((len=isr.read(chs))!=-1){
            osw.write(chs, 0, len);
            osw.flush();
        }

        isr.close();
        osw.close();




    }

}

 d.由于我们常见的操作都是使用本地默认编码，所以，不用指定编码。 而转换流的名称有点长，所以，Java就提供了其子类供我们使用。
 FileWriter和FileReader

    public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileReader fr = new FileReader("a.txt");
        // 封装目的地
        FileWriter fw = new FileWriter("b.txt");

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

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

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

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

    public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        // BufferedWriter(Writer out)
        // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
        // new FileOutputStream("bw.txt")));

        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

        bw.write("hello");
        bw.write("world");
        bw.write("java");
        bw.flush();

        bw.close();
    }
}

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        // 创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

        // 方式1
        // int ch = 0;
        // while ((ch = br.read()) != -1) {
        // System.out.print((char) ch);
        // }

        // 方式2
        char[] chs = new char[1024];
        int len = 0;
        while ((len = br.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

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

 f.字符缓冲流的特殊方法：
  BufferedWriter:
    public void newLine():根据系统来决定换行符
  BufferedReader:
    public String readLine()：一次读取一行数据
    包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

public class BufferedDemo {
    public static void main(String[] args) throws IOException {
        // write();
        read();
    }

    private static void read() throws IOException {
        // 创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));

        // public String readLine()：一次读取一行数据
        // String line = br.readLine();
        // System.out.println(line);
        // line = br.readLine();
        // System.out.println(line);

        // 最终版代码
        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

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

    private static void write() throws IOException {
        // 创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
        for (int x = 0; x < 10; x++) {
            bw.write("hello" + x);
            // bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }

}

`

public class CopyFileDemo2 {
public static void main(String[] args) throws IOException {
    // 封装数据源
    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    // 封装目的地
    BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

    // 读写数据
    String line = null;
    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

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

}

“`