devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java基础io流——OutputStream和InputStream InputStreamReader和BufferedReader FileReader、FileWriter_bufferedreader和inputstream close

作者：知新_RL | 2024-02-26 21:10:06

赞

踩

bufferedreader和inputstream close

java基础io流——OutputStream和InputStream的故事（温故知新）  https://www.jianshu.com/p/63d1751d3eac

java基础io流——字符流的变革（深入浅出）  https://www.jianshu.com/p/9f3fd98ec28b

 

java基础io流——OutputStream和InputStream的故事（温故知新）

io流概述：

IO流用来处理设备之间的数据传输，上传文件和下载文件，Java对数据的操作是通过流的方式，Java用于操作流的对象都在IO包中。

IO流分类

按照数据流向

输入流 读入数据

输出流 写出数据

按照数据类型

字节流

字符流

什么情况下使用哪种流呢?

如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流，其他用字节流。

如果你什么都不知道，就用字节流。

IO流常用基类

字节流的抽象基类：

InputStream ，OutputStream。

字符流的抽象基类：

Reader ， Writer。

注：
由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。

OutputStream的子类FileOutputStream

构造方法：

FileOutputStream(File file)

FileOutputStream(String name)

推荐第二种构造方法：

FileOutputStream outputStream = new FileOutputStream("a.txt");

创建字节输出流对象了做了几件事情：

  1. A:调用系统功能去创建文件
  2. B:创建outputStream对象
  3. C:把foutputStream对象指向这个文件

通过字节输出流写出数据到文本

  1. public void write(int b)
  2. public void write(byte[] b)
  3. public void write(byte[] b,int off,int len)

从方法中可看出，只能通过字节写出

  1. outputStream.write("hello".getBytes()); 文本中出现hello
  2. outputStream.write(96)  //文本中出现 a
  3.  
  4. byte[] bys={97,98,99,100,101};
  5. outputStream.write(bys,1,3); 文本中出现bcd

如此写出，文本中数据不会换行，不会追加，每次写出都是覆盖原来。

追加：

  1. FileOutputStream outputStream = new FileOutputStream("a.txt",true);
  2. //第二个参数true设置为可追加。

换行 \n\r ：

  1. for (int i = 0; i <5 ; i++) {
  2.     outputStream.write("hello".getBytes());
  3.     outputStream.write("\n\r".getBytes());
  4.     }

注：用完流一定要记得关闭。

outputStream.close();

完整示例：

  1. package io2;
  2.  
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. /**
  6.  * new FileOutputStream("a.txt",true);  第二个参数true，设置为写入的数据拼接在尾部
  7.  * \n\r 换行
  8.  * write(bys,1,3);  写入字节数组
  9.  */
  10. public class out {
  11.     public static void main(String args[]){
  12.         FileOutputStream outputStream = null;
  13.         try {
  14.             //FileOutputStream fos = new FileOutputStream(file);
  15.             outputStream = new FileOutputStream("a.txt",true);
  16.             /*
  17.              * 创建字节输出流对象了做了几件事情：
  18.              * A:调用系统功能去创建文件
  19.              * B:创建outputStream对象
  20.              * C:把foutputStream对象指向这个文件
  21.              */
  22.  
  23. //            for (int i = 0; i <5 ; i++) {
  24. //                outputStream.write("hello".getBytes());
  25. //                outputStream.write("\n\r".getBytes());
  26.                   
  27. //            }
  28.             byte[] bys={97,98,99,100,101};
  29.             outputStream.write(bys,1,3);
  30.         } catch (IOException e) {
  31.             e.printStackTrace();
  32.         }
  33.         finally {
  34.             try {
  35.                 outputStream.close();
  36.             } catch (IOException e) {
  37.                 e.printStackTrace();
  38.             }
  39.         }
  40.  
  41.  
  42.     }
  43. }
  44.

InputStream的子类FileInputStream

FileInputStream的构造方法

  1. FileInputStream(File file)
  2. FileInputStream(String name)

推荐第二种构造方法：

 FileInputStream inputStream = new FileInputStream("a.txt");

把刚才写的数据现在读取到控制台：

  1. public int read()
  2. public int read(byte[] b)

第一个read是读一个字节，第二个read是读一个字节数组。

  1. //读一个字节
  2. int by = 0;
  3. while ((by=inputStream.read())!=-1){
  4.       System.out.println((char)by);
  5. }

读到没数据了就返回-1，这个用来判断是否读完。

  1. //读一个字节数组，一般是1024大小
  2. int len = 0 ;
  3. byte[] bys = new byte[1024];
  4. while ((len = inputStream.read(bys)) != -1) {
  5.     System.out.println(new String(bys,0,len));
  6. }

两个read的返回值略有不同，read()返回读取的字节，读到末尾返回-1，read(byte[] b)返回的是读到的字节个数，读到的字节放在了bytes字节数组里，读到末尾没数据了返回-1。

两种读取方式图解：

 

同样的用完了流，也要及时的关闭，以防占用内存。

inputStream.close();

完整示例：

建议以字节数组的方式读取数据。

  1. package io2;
  2.  
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6.  
  7. /**
  8.  * Create by stefan
  9.  * Date on 2018-05-27  23:00
  10.  * Convertion over Configuration!
  11.  */
  12. public class input2 {
  13.     public static void main(String args[]){
  14.         FileInputStream inputStream = null;
  15.         try {
  16.             inputStream = new FileInputStream("a.txt");
  17. //            byte[] bys = new byte[4];
  18. //            int len = inputStream.read(bys);
  19. //            System.out.println(new String(bys));  //bcd
  20. //            System.out.println(len);  //3
  21. //            System.out.println(inputStream.read(bys));  //-1
  22.             int len = 0 ;
  23.             byte[] bys = new byte[1024];
  24.             while ((len = inputStream.read(bys)) != -1) {
  25.                 System.out.println(new String(bys,0,len));
  26.             }
  27.             /**
  28.              *    public String(byte bytes[]) {
  29.              this(bytes, 0, bytes.length);
  30.              }
  31.              */
  32.  
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         }finally {
  36.             try {
  37.                 inputStream.close();
  38.             } catch (IOException e) {
  39.                 e.printStackTrace();
  40.             }
  41.         }
  42.  
  43.     }
  44. }
  45.

字节流复制文件

利用输入流读取一个文件里的字节，再利用输出流将读取到的字节写出到另一个文件中（不存在会自动创建）

  1. package io2;
  2.  
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.util.Arrays;
  8.  
  9. /**
  10.  * Create by stefan
  11.  * Date on 2018-05-27  23:19
  12.  * Convertion over Configuration!
  13.  */
  14. public class copy {
  15.     public static void main(String args[]) throws IOException {
  16.         FileInputStream inputStream = new FileInputStream("E:\\huge1.jpg");
  17.         FileOutputStream outputStream = new FileOutputStream("E:\\古月.jpg");
  18.         
  19.         byte[] bytes = new byte[1024];
  20.         int len = 0;
  21.         while ((len=inputStream.read(bytes)) != -1) {
  22.             outputStream.write(bytes,0,len);
  23.             outputStream.flush();
  24.         }
  25.         inputStream.close();
  26.         outputStream.close();
  27.     }
  28. }
  29.

注：复制文本、图片、mp3、视频等的方式一样。

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果。

java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流。

  1. 字节缓冲输出流
  2. BufferedOutputStream
  3. 字节缓冲输入流
  4. BufferedInputStream

BufferedOutputStream

  1. BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt",true));
  2. bos.write("hello world".getBytes());
  3. bos.close();

BufferedInputStream

  1. BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
  2. byte[] bytes = new byte[1024];
  3. int len = 0;
  4. while ((len=bis.read(bytes)) != -1) {
  5.     System.out.println(new String(bytes,0,len));
  6. }
  7. bis.close();

注：

  • 成员方法与字节流基本一样，字节缓冲流的作用就是提高输入输出的效率。
  • 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
  • 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。

复制文件的升级：

  1. BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
  2. BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
  3. int len = 0;
  4. byte[] bytes =new byte[1024];
  5. while ((len=bis.read(bytes)) != -1) {
  6.     bos.write(bytes,0,len);
  7.     bos.flush();
  8. }
  9. bis.close();
  10. bos.close();

测试：四种复制文件的效率高低

  1. package io2;
  2.  
  3. import java.io.*;
  4.  
  5. /**
  6.  *
  7.  * 测试复制的时间
  8.  * Create by stefan
  9.  * Date on 2018-05-28  10:28
  10.  * Convertion over Configuration!
  11.  */
  12. public class copy2 {
  13.     //一个字节一个字节的复制，耗时22697毫秒
  14.     public static  void  fun() throws IOException {
  15.         FileInputStream fis = new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf");
  16.         FileOutputStream fos = new FileOutputStream("E:\\modern-java.pdf");
  17.         int by = 0;
  18.         while ((by=fis.read()) != -1) {
  19.             fos.write(by);
  20.             fos.flush();
  21.         }
  22.         fis.close();
  23.         fos.close();
  24.     }
  25.     //1024字节数组复制 耗时63毫秒
  26.     public  static void  fun1() throws IOException {
  27.         FileInputStream fis = new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf");
  28.         FileOutputStream fos = new FileOutputStream("E:\\modern-java.pdf");
  29.         int len = 0;
  30.         byte[] bytes =new byte[1024];
  31.         while ((len=fis.read(bytes)) != -1) {
  32.             fos.write(bytes,0,len);
  33.             fos.flush();
  34.         }
  35.         fis.close();
  36.         fos.close();
  37.     }
  38.     // 一个字节一个字节复制，但是用了缓冲流 耗时64毫秒
  39.     public static   void  fun2() throws IOException {
  40.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
  41.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
  42.         int by = 0;
  43.         while ((by=bis.read()) != -1) {
  44.             bos.write(by);
  45.             bos.flush();
  46.         }
  47.         bis.close();
  48.         bos.close();
  49.     }
  50.     // 1024字节数组复制并用了缓冲流 耗时7毫秒
  51.     public  static void  fun3() throws IOException {
  52.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
  53.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
  54.         int len = 0;
  55.         byte[] bytes =new byte[1024];
  56.         while ((len=bis.read(bytes)) != -1) {
  57.             bos.write(bytes,0,len);
  58.             bos.flush();
  59.         }
  60.         bis.close();
  61.         bos.close();
  62.     }
  63.  
  64.     public static void main(String args[]) throws IOException {
  65.         long t1 = System.currentTimeMillis();
  66.         fun3();
  67.         long t2 = System.currentTimeMillis();
  68.         System.out.println(t2-t1);
  69.     }
  70.  
  71. }
  72.

经测试结果显示：
1024字节数组复制并用了缓冲流 的方式效率最高。



java基础io流——字符流的变革（深入浅出）

乱码导火索：

在io流里，先诞生了字节流，但是字节流读取数据会有乱码的问题（读中文会乱码）。比如：

  1. FileInputStream fis = new FileInputStream("a.txt");
  2. //        int by = 0;
  3. //        while ((by=fis.read() )!= -1) {
  4. //            System.out.print((char)by);//bcdbcdbcdbcdbcdbcdhello 中�
  5. //            //因为还正常，中文就乱码了，有什么办法解决吗，有，就是有点麻烦
  6. //        }

从文件中读取中文会有乱码，当然字节流有解决措施。

  1. FileInputStream fis = new FileInputStream("a.txt");
  2. byte[] bytes = new byte[1024];
  3.         int len = 0;
  4.         while ((len = fis.read(bytes)) != -1) {
  5.             System.out.println(new String(bytes,0,len));//bcdbcdbcdbcdbcdbcdhello 中国
  6.             //查看new String()的源码，this.value = StringCoding.decode(bytes, offset, length);
  7.             //点进decode，循序渐进发现，默认编码是UTF-8
  8.             //通过源码，也看到了这个方法public String(byte bytes[], int offset, int length, String charsetName)
  9.  
  10.         }

但是解码这并不是字节流做的，而是String的功能。查看String的源码，构造方法有解码功能，并且默认编码是utf-8。

聊到了乱码，我觉得有必要聊一下编码的知识。

  1. String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
  2. byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组
  3.  
  4. 编码:把看得懂的变成看不懂的
  5. String -- byte[]
  6.  
  7. 解码:把看不懂的变成看得懂的
  8. byte[] -- String

因此字节流读取的数据是编码过的数据，我们解码就行了。

编码问题简单，只要编码解码的格式是一致的。

计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。

  1.      ASCII：美国标准信息交换码。
  2.      用一个字节的7位可以表示。
  3.      ISO8859-1：拉丁码表。欧洲码表
  4.      用一个字节的8位表示。
  5.      GB2312：中国的中文编码表。
  6.      GBK：中国的中文编码表升级，融合了更多的中文文字符号。
  7.      GB18030：GBK的取代版本
  8.      BIG-5码 ：通行于台湾、香港地区的一个繁体字编码方案，俗称“大五码”。
  9.      Unicode：国际标准码，融合了多种文字。
  10.      所有文字都用两个字节来表示,Java语言使用的就是unicode
  11.      UTF-8：最多用三个字节来表示一个字符。
  12.  
  13.      UTF-8不同，它定义了一种“区间规则”，这种规则可以和ASCII编码保持最大程度的兼容：
  14.      它将Unicode编码为00000000-0000007F的字符，用单个字节来表示�
  15.      它将Unicode编码为00000080-000007FF的字符用两个字节表示 
  16.      它将Unicode编码为00000800-0000FFFF的字符用3字节表示

示例：

  1.         String s = "你好";
  2.         byte[] bytes1 = s.getBytes();
  3.         System.out.println(Arrays.toString(bytes1));//[-28, -67, -96, -27, -91, -67]  默认编码utf-8
  4.  
  5.         byte[] bytes2 = s.getBytes("GBK");
  6.         System.out.println(Arrays.toString(bytes2));//[-60, -29, -70, -61]
  7.         byte[] bytes3 = s.getBytes("UTF-8");
  8.         System.out.println(Arrays.toString(bytes3));//[-28, -67, -96, -27, -91, -67]
  9.  
  10.         String s1 = new String(bytes1);
  11.         System.out.println(s1);//你好
  12.         String s2 = new String(bytes2,"GBK");
  13.         System.out.println(s2);//你好
  14.  
  15.         String s3 = new String(bytes2,"gbk");
  16.         System.out.println(s3);//你好
  17.  
  18.         String s4 = new String(bytes3);
  19.         System.out.println(s4);//你好
  20.  
  21.         String s5 = new String(bytes3,"gbk");
  22.         System.out.println(s5);//浣犲ソ

虽然字节流有解决乱码的方案，但并不方便，所以java io流就设计出了转换流，一场乱码引发的变革。
（OutputStreamWriter、InputStreamReader）

OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流

OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
把字节流转换为字符流。

  1. //创造对象
  2. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));//查看源码，java8 默认utf-8
  3. //写数据
  4. osw.write("中国");
  5. //释放资源
  6. osw.close();//close包含了close和flush的作用

一般默认编码就够了。

查看源码，发现OutputStreamWriter有5个write方法。

  1. /*
  2.  * OutputStreamWriter的方法：
  3.  * public void write(int c):写一个字符
  4.  * public void write(char[] cbuf):写一个字符数组
  5.  * public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
  6.  * public void write(String str):写一个字符串
  7.  * public void write(String str,int off,int len):写一个字符串的一部分
  8.  *
  9.  * 面试题：close()和flush()的区别?
  10.  * A:close()关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。
  11.  * B:flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。
  12.  */
  13.  
  14.  OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("c.txt"));//查看源码，java8 默认utf-8
  15.        //写一个字符
  16.         osw.write('a');
  17.         osw.write(97);
  18.         osw.write('中');
  19.         // 为什么数据没有进去呢?
  20.         // 原因是：字符 = 2字节
  21.         // 文件中数据存储的基本单位是字节。
  22.         // void flush()
  23.         osw.flush();
  24.         //写一个字符数组
  25.         char[] chars = {'a','b','中','国'};
  26.         osw.write(chars);
  27.         osw.flush();
  28.         //写一个字符数组的一部分
  29.         osw.write(chars,2,2);
  30.         osw.flush();
  31.         //写一个字符串
  32.         osw.write("\n\r中国");
  33.         //写一个字符串的一部分
  34.         osw.write("中国你好",2,2);
  35.         osw.close();

InputStreamReader(InputStream is):用默认的编码读取数据，默认utf-8

InputStreamReader(InputStream is,String charsetName):
用指定的编码读取数据

  1. //创建对象
  2. InputStreamReader isr = new InputStreamReader(new FileInputStream("b.txt"));//默认编码utf-8
  3. InputStreamReader isr1 = new InputStreamReader(new FileInputStream("b.txt"),"gbk");//可指定编码
  4.  
  5. //读数据
  6. int ch = 0;
  7. while ((ch = isr.read()) != -1) {
  8.     System.out.print((char)ch);//中国
  9. }
  10. //释放资源
  11. isr.close();
  12. //只有文档的编码和读取的编码一致才不会乱码。

查看源码知道InputStreamReader有2个read方法。

  1. /*
  2.  * InputStreamReader的方法：
  3.  * int read():一次读取一个字符
  4.  * int read(char[] chs):一次读取一个字符数组
  5.  */
  7. InputStreamReader isr = new InputStreamReader(new FileInputStream("c.txt"));
  8.         //读一个字符
  9. //        int ch = 0;
  10. //        while ((ch = isr.read()) != -1) {
  11. //            System.out.print((char) ch);//9797200139798200132226920013222691020013222692032022909/
  12. //            //aa中ab中国中国
  13. //            //中国你好
  14. //        }
  15.         //isr.close();
  16.         //读一个字符数组
  17.         char[] chars =new char[1024];
  18.         int len = 0;
  19.         while ((len = isr.read(chars)) != -1) {
  20.             System.out.println(chars.length);//1024
  21.             System.out.println(new String(chars,0,len));
  22.             //aa中ab中国中国
  23.             //中国你好
  24.         }
  25.         isr.close();

现在我们可以通过转换流升级字节流复制文件的方式了。

  1. InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
  2. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("e:\\a.txt"));
  3. char [] chars = new char[1024];
  4. int len  = 0 ;
  5. while ((len = isr.read(chars)) != -1) {
  6.     osw.write(chars,0,len);
  7.     osw.flush();
  8. }
  9. osw.close();
  10. isr.close();

字符流的诞生：

转换流已经是字符流了，但是他们的名字太长了，Java就提供了其子类供我们使用。

FileWriter 、FileReader 继承了其父类的所有方法。

字符流=字节流+编码表

OutputStreamWriter = FileOutputStream + 编码表(GBK)

FileWriter = FileOutputStream + 编码表(GBK)

InputStreamReader = FileInputStream + 编码表(GBK)

FileReader = FileInputStream + 编码表(GBK)

复制改写：

  1. FileWriter fw  = new FileWriter("e:\\b.txt");
  2. FileReader fr = new FileReader("b.txt");
  3. char[] chars =new char[1024];
  4. int len = 0;
  5. while ((len = fr.read(chars)) != -1) {
  6.     fw.write(chars,0,len);
  7.     fw.flush();
  8.     }
  9. fw.close();
  10. fr.close();
  11.    /**
  12.      * 总结，到现在为止，加上字节流，复制文本的方式有8种，但是复制图片视频等文件只有四种字节流的方式，因为不能用字符流复制图片视频mp3等
  13.      */

字符流学习前辈字节流的经验，也设计了字符缓冲流。

BufferedReader、
BufferedWriter

和字节缓冲流的设计基本一样，也有两个构造方法，但是我们只要默认的缓冲大小的构造方法就可以了。

用字符缓冲流改写复制功能：

  1. BufferedReader br = new BufferedReader(new FileReader("c.txt"));
  2. BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\d.txt"));
  3. char[] chars = new char[1024];
  4. int len = 0 ;
  5. while ((len = br.read(chars)) != -1) {
  6.     bw.write(chars,0,len);
  7.     bw.flush();
  8. }
  9. br.close();
  10. bw.close();

然而字符缓冲流还有自己特殊的读写功能。

BufferedWriter ：void newLine() 换行

BufferedReader ：String readLine() 读一行数据

  1. public static void main(String args[]) throws IOException {
  2.        // write();
  3.         read();
  4. }
  5.  
  6.     private static void read() throws IOException {
  7.         BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
  8.         String line = null;
  9.         while ((line = br.readLine()) != null) {
  10.             System.out.println(line);
  11.             //readLine不会读取换行符
  12.             //读到末尾返回null
  13.         }
  14.         br.close();
  15.     }
  16.  
  17.     private static void write() throws IOException {
  18.         BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
  19.         for (int i = 0; i <10 ; i++) {
  20.             bw.write("你好哈哈哈哈哈");
  21.             bw.newLine();//换行，并且自动检测不同系统的换行符
  22.             bw.flush();
  23.             //一般三个连用
  24.         }
  25.         bw.close();
  26.     }

用字符缓冲流的特殊方式升级复制功能：

  1. BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
  2. BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\bw.txt"));
  3.  
  4. String line = null;
  5. while ((line = br.readLine()) != null) {
  6.     bw.write(line);
  7.     bw.newLine();
  8.     bw.flush();
  9.     }
  10. bw.close();
  11. br.close();
  12.  
  13.  
  14.     //总结  字符流复制文本有5种方式

字符流的基础基本就聊完了，还有一个比较常用的类LineNumberReader

查看源码可知LineNumberReader继承自BufferedReader，并且增加了行号的操作。

  1. LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt"));
  2. String line = null;
  3. while ((line = lnr.readLine()) != null) {
  4.     System.out.println(lnr.getLineNumber()+":"+line);
  5. }
  6.  
  7. 1:A
  8. 2:S
  9. 3:F

但是LineNumberWriter。源码很简单，更多的操作请看源码。


PrintWrite PringStream StringWrite 的使用

https://blog.csdn.net/weixin_41547486/article/details/79917815

 

打印流：只做输出没有输入

打印流分为字节打印流和字符打印流 

PrintWriter：字符打印流

特点

1.    可以打印各种数据类型。

2.    封装了字符输出流，还可以做字符流和字节流的转换

3.    可以使用自动刷新。只有在调用println、printf或者format的其中一个方法时才可能完成此操作。

4.    可以直接向文件中写数据。
 

 

  1. 使用字符打印流向文件中写入数据
  2. public  class PrintDemo {
  3.     public  static  void main(String[] args) {
  4.            PrintWriter pw = null;
  5.  
  6.         try {
  7.  
  8.            //创建字符打印流对象
  9.  
  10.            pw = new PrintWriter("e.txt");
  11.  
  12.            //向文件中分别打印boolean、字符、int、字符串
  13.  
  14.            pw.print(true);
  15.  
  16.            pw.print('a');
  17.  
  18.            pw.print(12);
  19.  
  20.            pw.print("李昆鹏");
  21.  
  22.            //刷新
  23.  
  24.            pw.flush();
  25.  
  26.         } catch (FileNotFoundException e) {
  27.  
  28.            e.printStackTrace();
  29.  
  30.         }finally {
  31.  
  32.            //字符打印流也是需要关闭的，但是不用处理异常
  33.  
  34.            if(pw != null)
  35.  
  36.            pw.close();
  37.  
  38.         }    
  39.  
  40.     }
  41. }
  1.  从文件中读取数据并且打印在控制台
  2. public  class PrintDemo2 {
  3.     public  static  void main(String[] args) {
  4.  
  5.            BufferedReader br = null;
  6.  
  7.            PrintWriter pw = null;
  8.  
  9.         try {
  10.  
  11.            //创建高效缓冲区字符输入流对象
  12.  
  13.            br = new  BufferedReader(new FileReader("Student.txt"));
  14.  
  15.            //创建打印流对象
  16.  
  17.            //pw = new PrintWriter(System.out);
  18.  
  19.            //设置自动刷新的打印流在文件对象后面加true
  20.  
  21.            pw = new  PrintWriter(System.out,true);
  22.  
  23.            String line = null;
  24.  
  25.            while((line = br.readLine()) != null) {
  26.  
  27.                pw.println(line);
  28.  
  29.                //当使用自动刷新构造器时就不需要手动刷新
  30.  
  31.                //pw.flush();
  32.  
  33.            }
  34.  
  35.         } catch (FileNotFoundException e) {
  36.  
  37.            e.printStackTrace();
  38.  
  39.         } catch (IOException e) {
  40.  
  41.            e.printStackTrace();
  42.  
  43.         }finally {
  44.  
  45.            try {
  46.  
  47.                if(br != null)
  48.  
  49.                br.close();
  50.  
  51.                if(pw != null)
  52.  
  53.                pw.close();
  54.  
  55.            } catch (IOException e) {
  56.  
  57.                e.printStackTrace();
  58.  
  59.            }
  60.  
  61.         }    
  62.  
  63.     }
  1. 范例：使用打印流来复制文本文件
  2.  
  3. public  class PrintDemo3 {
  4.  
  5.     public  static  void main(String[] args) {
  6.  
  7.            BufferedReader br = null;
  8.            PrintWriter pw = null;
  9.  
  10.         try {
  11.  
  12.            //创建高效缓冲区字符输入流对象
  13.  
  14.            br = new  BufferedReader(new FileReader("Student.txt"));
  15.  
  16.            //创建打印流对象
  17.  
  18.            //pw = new PrintWriter(System.out);
  19.  
  20.            //设置自动刷新的打印流在文件对象后面加true
  21.  
  22.            pw = new PrintWriter(new FileWriter("Student1.txt"));
  23.  
  24.            String line = null;
  25.  
  26.            while((line = br.readLine()) != null) {
  27.  
  28.                pw.println(line);
  29.  
  30.                //当使用自动刷新构造器时就不需要手动刷新
  31.  
  32.                //pw.flush();
  33.  
  34.            }
  35.  
  36.         } catch (FileNotFoundException e) {
  37.  
  38.            e.printStackTrace();
  39.  
  40.         } catch (IOException e) {
  41.  
  42.            e.printStackTrace();
  43.  
  44.         }finally {
  45.  
  46.            try {
  47.  
  48.                if(br != null)
  49.  
  50.                br.close();
  51.  
  52.                if(pw != null)
  53.  
  54.                pw.close();
  55.  
  56.            } catch (IOException e) {
  57.  
  58.                e.printStackTrace();
  59.  
  60.            }
  61.  
  62.         }
  63.  
  64.     }
  65.  
  66. }
  67.  
  68.  
  1. 打印字符串中
  2. StringWriter sw = null;
  3.         PrintWriter pw = null;
  4.  
  5.         try {
  6.             sw = new StringWriter();
  7.             pw = new PrintWriter(sw);
  8.             e.printStackTrace(pw);
  9.             pw.flush();
  10.             sw.flush();
  11.         } catch (Exception var12) {
  12.             ;
  13.         } finally {
  14.             if(sw != null) {
  15.                 try {
  16.                     sw.close();
  17.                 } catch (Exception var11) {
  18.                     ;
  19.                 }
  20.             }
  21.  
  22.             if(pw != null) {
  23.                 pw.close();
  24.             }
  25.  
  26.         }
  27.  
  28.         String str = sw.toString();
  29.         return str.substring(0, str.length() - 1 > 300?300:str.length() - 1);

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/147132
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号