Java文档流-字符FileReader输入流、BufferedReader(缓存字符流）、-字符FileWriter输入流、BufferedWriter(缓存字符流）实例解析

• 字符流常用方法

  • Reader
    • int read()
    • int read(char[] c)
    • read(char[] c,int off,int len)
    • void close
      • 所有流都需要关闭，不然会造成内存泄漏
      • 先开的后关，后开的先关
    • 子类InputStreamReader常用的构造方法
      • （使用这个子类的前提是新建一个字节流对象）
      • InputStreamReader(InputStream in)：以字节输入流对象作为参数
      • InputStreamReader(InputStream in,String charsetName)：以字节输入流对象作为参数和字符编码类型作为参数
      • 子类FileReader类
        • 该类只能按照本地平台的字符编码格式来读取数据，用户不能指定其他字符编码类型
          • System.out.print(System.getProperty("file.encoding"));
          • 获取本地平台的编码格式
        • FileReader类是InputStreamReader的子类
          • 构造方法
          • FileReader（File file）
          • FileReader（String name）
        • 使用FileReader类读取文件
          • 引入相关类
            • import java.io.Reader;
            • import java.io.FileReader;
            • import java.io.IOExceprion;
          • 创建FileReader对象
            • Reader fr=new FileReader("D:\\test.txt")
          • 读取文本数据
            • fr.read();
          • 关闭流对象
    • 子类BufferedReader(缓存字符流）
      • 使用前提为一定要有字符流对象（InputStreamReader或FileReader）
      • BufferedReader构造方法
        • 以Reader或Reader的子类或孙子类的实现对象作为参数
        • InputStreamReader（使用这个需要一个字节流对象）或FileReader
      • int read()
      • int read(char[] c)
      • read(char[] c,int off,int len)
      • void close
        • 所有流都需要关闭，不然会造成内存泄漏
        • 先开的后关，后开的先关
      • 常用方法：readLine（）
        • FileReader fr=null;
        • BufferedReader br=null;
        • try{
        • fr=new FileReader("d:/test.txt");
        • br=new BufferedReader(fr);
        • StringBuffer sbf=new StringBuffer();
        • String str=null;
        • while（(str=br.readLine())!=null）{
        • sbf.append(str)
        • }
        • System.out.println(sbf)
      • BufferedWriter方法
        • BufferedWriter
        • 构造方法
        • 1.以Writer或者Writer的子类 孙子类的实现对象作为参数
        • OnputStreamWriter （使用这个子类的前提是先新建一个字节流对象）
        • FileWriter
        • 普通方法
        • 1.write(String str)
        • 2.write(String str,int off, int len)
        • 3.newLine() 换行
        • 5.close() 所有的流都要关闭，没有关闭的话会造成内存泄露（程序卡住了）
        • 所有打开流要遵循新开的后关，后开的先关

• 实例解析
• 测试类：字符FileReader输入流、BufferedReader(缓存字符流）、-字符FileWriter输入流、BufferedWriter(缓存字符流）

• public static void main(String[] args) {
              File file = new File("src/testBufferedRead/test.txt");
              System.out.println(System.getProperty("file.encoding"));
              try {
                  //新建此对象的txt文件
                  file.createNewFile();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              //判断是否创建成功
              if (file.exists()) {
                  String uri="src/testBufferedRead/test.txt";
                  Test test=new Test();
                  test.bufferedWrite(uri,"GBK");
                  test.bufferedRead(uri);
              }else{
                  System.out.println("不存在");
              }
          }

  FileReader方法单字符流输入，传入地址

  
          //FileReader方法单字符流输入，传入地址
          public void read(String uri){
              //新建空文件，防止流关闭时作用域不同
              FileReader fileReader=null;
              try {
                  //导入对象地址
                  fileReader=new FileReader(uri);
                  //一个字符一个字符读取
  //            int len=-1;
  //            while ((len=fileReader.read())!=-1){
  //                System.out.print((char) len);
  //            }
  //            System.out.println();
  
                  //1024个字符读取，将这些字符放入字符数组中
  //            char[] chars=new char[1024];
  //            while (fileReader.read(chars)!=-1){
  //                for (char c:chars) {
  //                    if (c!=0){
  //                        System.out.print(c);
  //                    }
  //                }
  //                System.out.println();
  //            }
                  //1024个字符读取，将这些字符放入字符数组中，设置了起始位置、和字符串（2）长度单位
                  char[] chars1=new char[1024];
                  while (fileReader.read(chars1,2,2)!=-1){
                      for (char c:chars1) {
                          if (c!=0){
                              System.out.print(c);
                          }
                      }
                  }
              } catch (FileNotFoundException e) {
                  e.printStackTrace();
              } catch (IOException e) {
                  e.printStackTrace();
              }finally {
                  try {
                      fileReader.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }

  //BufferedReader字符流输入，传入地址，编码格式，解决乱码问题

  
          //BufferedReader字符流输入，传入地址，编码格式，解决乱码问题
          public void bufferedRead(String uri,String format){
              //新建空文件，防止流关闭时作用域不同
              FileInputStream fis=null;
              InputStreamReader isr=null;
              BufferedReader br=null;
              try {
                  //使用字节流方法FileInputStream导入文件
                  fis=new FileInputStream(uri);
                  //多态的用法，设置字符编码（默认UTF-8）
                  isr=new InputStreamReader(fis,format);
                  br=new BufferedReader(isr);
                  String str=null;
                  while ((str=br.readLine())!=null){
                      System.out.println(str);
                  }
              } catch (FileNotFoundException e) {
                  e.printStackTrace();
              } catch (UnsupportedEncodingException e) {
                  e.printStackTrace();
              } catch (IOException e) {
                  e.printStackTrace();
              }finally {
                  try {
                      br.close();
                      isr.close();
                      fis.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }

  //BufferedReader字符流输入，传入地址

  
          //BufferedReader字符流输入，传入地址
          public void bufferedRead(String uri){
              //新建空文件流，防止流关闭时作用域不同
              FileReader fr=null;
              BufferedReader br=null;
              try {
                  //使用多态引入FileReader方法导入文件
                  fr=new FileReader(uri);
                  br=new BufferedReader(fr);
                  String str=null;
                  while ((str=br.readLine())!=null){
                      System.out.println(str);
                  }
              } catch (FileNotFoundException e) {
                  e.printStackTrace();
              } catch (UnsupportedEncodingException e) {
                  e.printStackTrace();
              } catch (IOException e) {
                  e.printStackTrace();
              }finally {
                  try {
                      br.close();
                      fr.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }

  //bufferedWrite字符流输出，传入地址

  
          //bufferedWrite字符流输出，传入地址
          public void bufferedWrite(String uri){
              //新建空文档流，防止关闭流时作用域报错
              FileWriter fw=null;
              BufferedWriter bw=null;
              try {
                  //多态写法，导入文件地址，是否覆盖写法（false表示覆盖）
                  fw=new FileWriter(uri,false);
                  bw=new BufferedWriter(fw);
                  //写入字符，如果文件内存在内容，则覆盖
                  bw.write("Java高级API文档流");
                  //写入字符，不会新起一行
                  bw.write("Java高级API文档流");
                  //新起一行
                  bw.newLine();
                  bw.write("学习中");
                  bw.newLine();
                  //刷新缓存
                  bw.flush();
              } catch (IOException e) {
                  e.printStackTrace();
              }finally {
                  try {
                      bw.close();
                      fw.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }

  //BufferedReader字符流输出，传入地址，编码格式，解决乱码问题

  
      //BufferedReader字符流输出，传入地址，编码格式，解决乱码问题
          public void bufferedWrite(String uri,String format){
              //新建空文档流，防止关闭流时作用域报错
              FileOutputStream fos=null;
              OutputStreamWriter osw=null;
              BufferedWriter bw=null;
              try {
                  //多态写法，导入文件地址，是否覆盖写法（true表示不覆盖）
                  fos=new FileOutputStream(uri,true);
                  //多态的用法，设置字符编码（默认UTF-8）
                  osw=new OutputStreamWriter(fos,format);
                  bw=new BufferedWriter(osw);
                  //写入字符，如果文件内存在内容，则覆盖
                  bw.write("Java高级API文档流");
                  //写入字符，不会新起一行
                  bw.write("Java高级API文档流");
                  //新起一行
                  bw.newLine();
                  bw.write("学习中");
                  bw.newLine();
                  //刷新缓存
                  bw.flush();
              } catch (IOException e) {
                  e.printStackTrace();
              }finally {
                  try {
                      bw.close();
                      osw.close();
                      fos.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }