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

最新推荐文章于 2024-08-18 23:52:24 发布

(っ´Ι`)っ球球别秀了

最新推荐文章于 2024-08-18 23:52:24 发布

阅读量1.1k

点赞数 1

文章标签： java 缓存 jvm

本文链接：https://blog.csdn.net/qq_32174147/article/details/128180277

版权

字符流常用方法
- 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();
                }
            }
        }