欢迎光临
我们一直在努力
        找回密码
当前位置：171主机测评 > 服务器技术 > 正文

io流(二)

2026-06-02 分类：服务器技术 阅读(26) 评论(0)

一、缓冲流

各位同学，昨天学习完字符流之后，今天我们学习一下缓冲流。

我们还是先来认识一下缓存流，再来说一下它的作用。缓冲流有四种，如下图所示

缓冲流的作用：可以对原始流进行包装，提高原始流读写数据的性能。

1.1 字节缓冲流

我们先来学习字节缓冲流是如何提高读写数据的性能的，原理如下图所示。

是因为在缓冲流的底层自己封装了一个长度为8KB（8192byte）的字节数组，但是缓冲流不能单独使用，它需要依赖于原始流。

  • 读数据时：它先用原始字节输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字节数组中读取一个字节或者多个字节（再消耗屯的货）。

  • 写数据时： 它是先把数据写到缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字节输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。

在创建缓冲字节流对象时，需要封装一个原始流对象进来。构造方法如下

如果我们用缓冲流复制文件，代码写法如下:

public class BufferedInputStreamTest {
   public static void main(String[] args) {
       try (
               // 1、创建一个字节输入流管道与源文件接通
               InputStream is = new FileInputStream("day12_io\\\\src\\\\sy02.txt");
               // 定义一个字节缓冲输入流包装原始的字节输入流
               InputStream bis = new BufferedInputStream(is);
               // 2、创建一个字节输出流管道与目标文件接通。
               OutputStream os = new FileOutputStream("day12_io\\\\src\\\\sy02_bak.txt");
               // 定义一个字节缓冲输出流包装原始的字节输出流
               OutputStream bos = new BufferedOutputStream(os)
          ){
           // 3、创建一个字节数组，负责转移字节数据。
           byte[] buffer = new byte[1024];
           // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
           int len;
           while ((len = bis.read(buffer)) != -1){
               bos.write(buffer, 0, len);
          }
           System.out.println("复制完成！！");
      } catch (Exception e){
           e.printStackTrace();
      }
  }
}

1.2 字符缓冲流

接下来，我们学习另外两个缓冲流——字符缓冲流。它的原理和字节缓冲流是类似的，它底层也会有一个8KB的数组，但是这里是字符数组。字符缓冲流也不能单独使用，它需要依赖于原始字符流一起使用。

  • BufferedReader读数据时：先原始字符输入流一次性读取8KB的数据存入缓冲流内部的数组中（ps: 先一次多囤点货），再从8KB的字符数组中读取一个字符或者多个字符（再消耗屯的货）。

创建BufferedReader对象需要用到BufferedReader的构造方法，内部需要封装一个原始的字符输入流，我们可以传入FileReader.

而且BufferedReader还要特有的方法，一次可以读取文本文件中的一行

使用BufferedReader读取数据的代码如下

public class BufferedReaderTest {
   public static void main(String[] args) {
       try (
               Reader fr = new FileReader("day12_io\\\\src\\\\sy04.txt");
               // 创建一个字符缓冲输入流包装原始的字符输入流
               BufferedReader br = new BufferedReader(fr);
      ){
           /*char[] buffer = new char[3];
           int len;
           while ((len = br.read(buffer)) != -1){
               System.out.print(new String(buffer, 0, len));
           }
           System.out.println(br.readLine());*/
​
           String line; // 记住每次读取的一行数据
           while ((line = br.readLine()) != null){
               System.out.println(line);
          }
      } catch (Exception e) {
           e.printStackTrace();
      }
  }
}

  • BufferedWriter写数据时： 它是先把数据写到字符缓冲流内部的8BK的数组中（ps: 先攒一车货），等数组存满了，再通过原始的字符输出流，一次性写到目标文件中去（把囤好的货，一次性运走）。如下图所示

创建BufferedWriter对象时需要用到BufferedWriter的构造方法，而且内部需要封装一个原始的字符输出流，我们这里可以传递FileWriter。

而且BufferedWriter新增了一个功能，可以用来写一个换行符

接下来，用代码演示一下，使用BufferedWriter往文件中写入字符数据。

public class BufferedWriterTest {
   public static void main(String[] args) {
       try (
               Writer fw = new FileWriter("day12_io\\\\src\\\\sy03.txt", true);
               // 创建一个字符缓冲输出流管道包装原始的字符输出流
               BufferedWriter bw = new BufferedWriter(fw);
      ){
​
           bw.write('a');
           bw.write(97);
           bw.write('东');
           bw.newLine();
​
           bw.write("我爱你中国abc");
           bw.newLine();
​
      } catch (Exception e) {
           e.printStackTrace();
      }
  }
}

二、转换流

2.1 问题：不同编码读取时会乱码

不同编码读取出现乱码问题时注意:
1. 如果代码编码和被读取的文本文件的编码是不一致的，使用字符流读取文本文件时就会出现乱码！
2. 如果代码编码和被读取的文本文件的编码是一致的，使用字符流读取文本文件时不会出现乱码！

public class BufferedReaderTest {
   public static void main(String[] args) {
       try (
           // 创建字符缓冲流对象与源文件接通
           // 代码编码是: UTF-8   文件编码是: UTF-8
           // BufferedReader br = new BufferedReader(new FileReader("day12_io\\\\src\\\\sy01.txt"));
           // 代码编码是: UTF-8   件编码是: GBK时   此时就会出现乱码
           BufferedReader br = new BufferedReader(new FileReader("day12_io\\\\src\\\\sy02.txt"));
          ){
           // 按行读取
           String line;
           while ((line = br.readLine()) != null){
               System.out.println(line);
          }
      } catch (Exception e){
           e.printStackTrace();
      }
  }
}

通过FileReader读取文件中的字符，同学们注意了，FileReader默认只能读取UTF-8编码格式的文件。如果使用FileReader读取GBK格式的文件，可能存在乱码，因为FileReader它遇到汉字默认是按照3个字节来读取的，而GBK格式的文件一个汉字是占2个字节，这样就会导致乱码。

Java给我们提供了另外两种流InputStreamReader，OutputStreamWriter，这两个流我们把它叫做转换流。它们可以将字节流转换为字符流，并且可以指定编码方案。

2.2 InputStreamReader类(字符输入转换流)

接下来，我们先学习InputStreamReader类，这个类名就比较有意思，前面是InputStream表示字节输入流，后面是Reader表示字符输入流，合在一起意思就是表示可以把InputStream转换为Reader，最终InputStreamReader其实也是Reader的子类，所以也算是字符输入流。

解决不同编码时，字符流读取文本内容乱码的问题。
解决思路：先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了。

InputStreamReader也是不能单独使用的，它内部需要封装一个InputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。

需求：我们可以先准备一个GBK格式的文件，然后使用下面的代码进行读取，看是是否有乱码。

public class InputStreamReaderTest {
   public static void main(String[] args) {
       try (
               // 1. 得到文件的原始字节流(GBK的字节形式)
               InputStream is = new FileInputStream("day12_io\\\\src\\\\sy02.txt");
               // 2. 把原始的字节输入流 按照 指定 的字符集编码转成 字符输入流
               Reader isr = new InputStreamReader(is, "GBK");
               // 3. 把 字符输入流 包装乘缓冲字符输入流
               BufferedReader br = new BufferedReader(isr);
      ){
           // 按行读取
           String line;
           while ((line = br.readLine()) != null){
               System.out.println(line);
          }
      } catch (Exception e){
           e.printStackTrace();
      }
  }
}

执行完之后，你会发现没有乱码。

2.3 OutputStreamWriter类(字符输出转换流)

接下来，我们先学习OutputStreamWriter类，你看这个类名也比较有意思，前面是OutputStream表示字节输出流，后面是Writer表示字符输出流，合在一起意思就是表示可以把OutputStream转换为Writer，最终OutputStreamWriter其实也是Writer的子类，所以也算是字符输出流。

作用：可以控制写出去的字符使用什么字符集编码。
解决思路：获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了。

OutputStreamReader也是不能单独使用的，它内部需要封装一个OutputStream的子类对象，再指定一个编码表，如果不指定编码表，默认会按照UTF-8形式进行转换。

需求：我们可以先准备一个GBK格式的文件，使用下面代码往文件中写字符数据。

public class OutputStreamWriterTest {
   public static void main(String[] args) {
       // 指定写出去的字符编码。
       try (
               // 1. 创建一个文件字节输出流
               OutputStream os = new FileOutputStream("day12_io\\\\src\\\\sy04.txt", true);
               // 2. 把原始的字节输出流，按照指定的字符集编码转换成字符输出转换流。
               Writer osw = new OutputStreamWriter(os, "GBK");
               // 3. 把字符输出流包装成缓冲字符输出流
               BufferedWriter bw = new BufferedWriter(osw);
      ){
           bw.write("我爱你柳岩666");
           bw.newLine();
           bw.write("我爱你柳岩888");
           bw.newLine();
      } catch (Exception e) {
           e.printStackTrace();
      }
  }
}

三、打印流(了解)

接下来，我们学习打印流，其实打印流我们从开学第一天就一直再使用，只是没有学到你感受不到而已。打印流可以实现更加方便，更加高效的写数据的方式。

3.1 打印流基本使用

打印流，这里所说的打印其实就是写数据的意思，它和普通的write方法写数据还不太一样，一般会使用打印流特有的方法叫print(数据)或者println(数据)，可以实现更方便、更高效的打印(写出)数据出去，能实现打印啥出去就是啥出去。

打印流有两个，一个是字节打印流PrintStream，一个是字符打印流PrintWriter，如下图所示

字节打印流PrintStream:

字符打印流PrintWriter:

PrintStream和PrintWriter的用法是一样的，所以这里就一块演示了。

public class PrintStreamTest1 {
   public static void main(String[] args) {
       try (
               // 创建一个打印流通道
               //PrintStream ps = new PrintStream("day12_io\\\\src\\\\sy05.txt", Charset.forName("GBK"));
               // PrintStream ps = new PrintStream("day12_io\\\\src\\\\sy05.txt");
               // 高级流不支持追加 需要使用低级流
               // PrintWriter ps = new PrintWriter("day12_io\\\\src\\\\sy05.txt");
               PrintWriter ps =
                       new PrintWriter(new FileOutputStream("day12_io\\\\src\\\\sy05.txt", true));
          ){
           ps.println(97); // 文件中显示的就是:97
           ps.println('a'); // 文件中显示的就是:a
           ps.println("我爱你中国abc"); // 文件中显示的就是:我爱你中国abc
           ps.println(true); // 文件中显示的就是:true
           ps.println(99.5); // 文件中显示的就是99.5
​
           ps.write(97); //文件中显示a
           ps.println();
​
      } catch (Exception e){
           e.printStackTrace();
      }
  }
}

1. PrintStream和PrintWriter的区别
打印数据的功能上是一模一样的：都是使用方便，性能高效（核心优势）
PrintStream继承自字节输出流OutputStream，因此支持写字节数据的方法。
PrintWriter继承自字符输出流Writer，因此支持写字符数据出去。
​
2. 打印流的优势是什么？
两者在打印功能上都是使用方便，性能高效（核心优势）因为底层使用了缓冲流。

3.2 重定向输出语句

其实我们开学第一课，就给同学们讲过System.out.println()这句话表示打印输出，但是至于为什么能够输出，其实我们一直不清楚。

以前是因为知识储备还不够，无法解释，到现在就可以给同学们揭晓谜底了，因为System里面有一个静态变量叫out，out的数据类型就是PrintStream，它就是一个打印流，而且这个打印流的默认输出目的地是控制台，所以我们调用System.out.pirnln()就可以往控制台打印输出任意类型的数据，而且打印啥就输出啥。

而且System还提供了一个方法，可以修改底层的打印流，这样我们就可以重定向打印语句的输出目的地了。我们玩一下, 直接上代码。

public class PrintStreamTest2 {
   public static void main(String[] args) {
       System.out.println("老骥伏枥");
       System.out.println("志在千里");
​
       try (
           PrintStream ps = new PrintStream("day12_io\\\\src\\\\sy06.txt");
      ){
           // 把系统默认的打印流对象改成自己设置的打印流
           System.setOut(ps);
​
           System.out.println("烈士暮年");
           System.out.println("壮心不已");
      } catch (Exception e) {
           e.printStackTrace();
      }
  }
}

此时打印语句，将往文件中打印数据，而不在控制台。

赞(0)
未经允许不得转载：171主机测评 » io流(二)
分享到： 更多 (0)
标签：

相关推荐

评论 抢沙发

取消

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

热门标签

#人工智能(57711)#python(19666)#开发语言(16542)#java(15192)#运维(15126)#linux(14755)#大数据(14322)#服务器(12885)#算法(11598)#前端(10678)#网络(9202)#数据库(8744)#ai(8634)#c++(8037)#课程设计(6757)#学习(6629)#机器学习(6603)#区块链(5835)#OpenClaw(5376)#后端(5053)#spring boot(4953)#深度学习(4837)#c语言(4318)#毕业设计(4273)#数据结构(4138)#安全(3940)#docker(3889)#架构(3765)#javascript(3760)#大模型(3591)

热门文章

最新文章

归档

分类