目录

字节缓冲流

能够高速读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等，这些功能强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。

概述

缓冲流，也叫高效流，是对4个基本的 FileXxx流的增强，所以也是4个流，按照数据类型分类：

  • 字节缓冲流：BufferedInputStream，BufferedOutputStream
  • 字符缓冲流：BufferedReader，BufferedWriter
  • 缓冲流的基本原理：是在创建流对象时，会创建一个内置大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

BufferedOutputStream类

  • java.io.BufferedOutputStream extends OutputStream
  • BufferedOutputStream：字节缓冲输入流。

继承父类的共性成员方法

  1. public void close()：关闭此输出流并释放与此流相联的任何系统资源。
  2. public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出。
  3. public void write(byte[] b)：将b.length字节从指定的字节数组写入此输出流。
  4. public void write(byte[] b, int off, int len)：从指定的字节数组写入 len字节，从偏移量 off开始输出至此输出流。
  5. public abstract void write(int b)：将指定的字节输出流。

构造方法

  • BufferedOutputStream(OutputStream out) ：创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
  • BufferedOutputStream(OutputStream out, int size) ：创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
  • 参数：
    • OutputStream out：字节输出流。我们可以传递FileOutputStream对象，缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率。
    • int size：指定缓冲流内部缓冲区数组的大小，不指定默认。

使用步骤（重点）：

  1. 创建FileOutputStream对象，构造方法中绑定要输出数据的目的地。
  2. 创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStrem的写入效率。
  3. 使用BufferedOutputStream对象中的方法 writer，把数据写入到内部缓冲区中。
  4. 使用BufferedOutputStream对象中的方法 flush，把内部缓冲区中的数据，刷新到文件中。
  5. 释放资源（会先调用 flush方法，刷新数据，第4步可以省略）。
  • 示例
  1. import java.io.BufferedOutputStream;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  5. public class Demo01BufferedOutputStream {
  6.     public static void main(String[] args) throws IOException {
  7.         // 1. 创建FileOutputStream对象，构造方法中传递要输出数据的目的地
  8.         FileOutputStream fos = new FileOutputStream("itcast-code\\a.txt");
  9.         // 2. 创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高写入的效率
  10.         BufferedOutputStream bos = new BufferedOutputStream(fos);
  11.         // 3. 调用BufferedOutputStream对象的方法，write写入数据
  12.         bos.write("我把数据写入到内部缓冲区中".getBytes());
  13.         // 4. 调用flush方法，刷新缓冲区
  14.         bos.flush();
  15.         // 5. 释放资源
  16.         bos.close();
  17.     }
  18. }

BufferedInputStream类

  • java.io.BufferedInputStream extends InputStream
  • BufferedInputStream：字节缓冲输入流。

继承自父类的方法：

  1. abstract int read()：从输入流中读取数据的下一个字节。
  2. int read(byte[] b)：从输入流中读取一定数量的字节，并将其存储到缓冲区数组 b 中。
  3. void close()：关闭此输入流并释放与该流关联的所有系统资源。

构造方法

  • BufferedInputStream(InputStream in) ：创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
  • BufferedInputStream(InputStream in, int size) ：创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
  • 参数：
    • InputStream in：字节输入流。我们可以传递FileInputStream对象，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream的读取效率。
    • int size：指定缓冲流内部缓冲区数组的大小，不指定默认。

使用步骤（重点）：

  1. 创建FileInputStream对象，构造方法中绑定要读取的数据源.。
  2. 创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStrem的读取效率。
  3. 使用BufferedInputStream对象中的方法 read，读取文件。
  4. 释放资源（会先调用 flush方法，刷新数据）。
  • 示例
  1. import java.io.BufferedInputStream;
  2. import java.io.FileInputStream;
  3. import java.io.IOException;
  5. public class Demo02BufferedInputStream {
  6.     public static void main(String[] args) throws IOException {
  7.         // 1. 创建FileInputStream对象，构造方法中绑定读取的数据源
  8.         FileInputStream fis = new FileInputStream("itcast-code\\a.txt");
  9.         // 2. 创建BufferedInputStream对象，构造方法中传递FileInputStream对象
  10.         BufferedInputStream bis = new BufferedInputStream(fis);
  11.         // 3. 调用BufferedInputStream中的方法，read，读取文件
  13.         // 一次读取一个字节的方式
  14. /*
  15.         int len = 0; // 记录每次读取字节的有效个数
  16.         while ((len = bis.read()) != -1) {
  17.             System.out.println((char)len);
  18.         }
  19. */
  20.         // 一次读取多个字节的方式
  21.         int len = 0; // 记录每次读取字节的有效个数
  22.         // 用来缓冲读取的字节
  23.         byte[] bytes = new byte[1024];
  24.         // 读取到文件末尾时，返回-1
  25.         while ((len = bis.read(bytes)) != -1) {
  26.             System.out.println(new String(bytes, 0, len));
  27.         }
  28.     }
  29. }

文件复制练习(增强版 使用缓冲流)

  1. import java.io.*;
  3. /*
  4. 使用缓冲流完成
  5.     文件复制练习：一读一写
  6.     明确：
  7.         数据源：
  8.         数据的目的地：
  9.     文件复制的步骤：
  10.         1. 创建字节缓冲输入流对象，构造方法中传递字节输入流对象。
  11.         2. 创建字节缓冲输出流对象，构造方法中传递字节输出流对像.
  12.         3. 使用字节缓冲输入流中的方法，read，读取文件。
  13.         4. 使用字节缓冲输出流中的方法 writer，把读取到的数据写入到内部缓冲区中。
  14.         5. 释放资源（会先把缓冲区中的数据，刷新到文件中）
  15.  */
  16. public class Demo03CopuFIle {
  17.     public static void main(String[] args) throws IOException {
  18. 		// 记录开始时间
  19.         long start = System.currentTimeMillis();
  20.         // 1. 创建字节缓冲输入流对象
  21.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\Pictures\\Saved Pictures\\3.jpeg"));
  22.         // 2. 创建字节缓冲输出流对象
  23.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\3.jpeg"));
  24.         // 3. 调用 read方法，读取文件
  25.         // 一次读取一个字节的方式
  26.         /*int len = 0;
  27.         while ((len = bis.read()) != -1) {
  28.             // 调用 write方法，写入数据
  29.             bos.write(len);
  30.         }*/
  31.         // 使用字节数组缓冲一次读取到的多个字节
  32.         byte[] bytes = new byte[1024];
  33.         int len = 0;
  34.         while ((len = bis.read(bytes)) != -1) {
  35.             bos.write(bytes, 0, len);
  36.         }
  38.         // 5. 释放资源
  39.         bos.close();
  40.         bis.close();
  41. 		// 结束时间
  42.         long end = System.currentTimeMillis();
  43.         System.out.println("文件复制耗费：" + (end - start) + "毫秒");
  44.     }
  45. }

字符缓冲流

  • java.io.BufferedWriter extends Writer
  • BufferedWriter：字符缓冲输出流。

BufferedWriter类

继承自父类的共性方法

  1. void writer(int c)：写入单个字符。
  2. void writer(char[ ] cbuf)：写入字符数组。
  3. abstract void writer(char[ ] cbuf, int off, int len)：写入字符数组的一部分，off：数组的开始索引，len：写的字符个数。
  4. void writer(String str)：写入字符串。
  5. void writer(String str, int off, int len)：写入字符串的一部分，off：字符串的开始索引，len：写入字符的个数。
  6. void flush()：刷新该流的缓冲区。
  7. void close()：关闭此流，但要先刷新它。

构造方法

  • BufferedWriter(Writer out) ：创建一个使用默认大小输出缓冲区的缓冲字符输出流。
  • BufferedWriter(Writer out, int sz) ：创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
  • 参数：
    • Writer out：字符输出流。我们可以传递 FileWriter对象，缓冲流会给 FileWriter增加一个缓冲区，提高 FileWriter的写入效率。
    • int sz：指定缓冲区的大小，不写默认大小。

特有的成员方法

  • void newLine() ：写入一个行分隔符。 会根据不同的操作系统，获取不同的行分隔符。
  • 换行：换行符号
    • Windows：\r\n
    • Linux：/n
    • mac：/r

使用步骤:

  1. 创建字符缓冲输出流对象，构造方法中传递字符输出流。
  2. 调用字符缓冲输出流对象中的方法 writer，把数据写入到内存缓冲区中。
  3. 调用字符缓冲输出流对象中的方法 flush，把内存缓冲区中的数据，刷新到文件中。
  4. 释放资源。
  • 示例：
  1. import java.io.BufferedWriter;
  2. import java.io.FileWriter;
  3. import java.io.IOException;
  5. public class Demo04BufferedWriter {
  6.     public static void main(String[] args) {
  8.         try (// 1. 创建字符缓冲输出流对象，构造方法中绑定字符输出流对象
  9.              BufferedWriter bw = new BufferedWriter(new FileWriter("itcast-code\\b.txt"));) {
  10.             for (int i = 0; i < 10; i++) {
  11.                 // 2. 调用字符缓冲输出流对象中的方法，writer，把数据写入到内存缓冲区中
  12.                 bw.write("我爱学习java，耶耶耶！");
  13.                 // 使用特有的方法，newLine()，换行
  14.                 bw.newLine();
  15.             }
  16.             // 3. 调用字符缓冲输出流对象中的方法，flush，把内存缓冲区中的数据，刷新到文件中
  17.             bw.flush();
  18.         } catch (IOException e) {
  19.             System.out.println(e);
  20.         }
  22.         // 4. 释放资源
  23.         // bw.close();
  24.     }
  25. }

BufferedReader类

  • java.io.BufferedReader extends Reader
  • BufferedReader：字符缓冲输入流

继承自父类的共性方法

  1. int read()：读取单个字符并返回。
  2. int read(char[ ] cbuf)：一次读取多个字符，将字符读入数组。
  3. void close()：关闭该流并释放与之关联的所有资源。

构造方法

  • BufferedReader(Reader in) ：创建一个使用默认大小输入缓冲区的缓冲字符输入流。
  • BufferedReader(Reader in, int sz) ：创建一个使用指定大小输入缓冲区的缓冲字符输入流。
  • 参数：
    • Reader in：字符输入流。我们可以传递 FileReader，缓冲流会给 FileReader增加一个缓冲区，提高 FileReader的读取效率。
    • int sz：指定缓冲区的大小，不写默认大小。

特有的成员方法

  • String readLine() ：读取一个文本行。读取一行数据。
  • 通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行 ( \r\n )。
  • 返回值：
    • 包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。

使用步骤：

  1. 创建字符缓冲输入流对象，构造方法中传递字符输入流对象。
  2. 使用字符输入流对象中的方法，read / readLine，读取文本。
  3. 释放资源。
  • 示例：
  1. import java.io.BufferedReader;
  2. import java.io.FileReader;
  3. import java.io.IOException;
  5. public class Demo05BufferedReader {
  6.     public static void main(String[] args) throws IOException {
  7.         // 1. 创建字符缓冲输入流对象，构造方法中绑定字符输入流对象
  8.         BufferedReader br = new BufferedReader(new FileReader("itcast-code\\b.txt"));
  9.         /*
  10.             在不知道文本中有多少行时，使用while循环
  11.             while的结束条件，读取到 null时结束
  12.          */
  13.         // 2. 使用字符缓冲输入流对象中的方法，read / readLine，读取文本
  14.         String line;
  15.         while ((line = br.readLine()) != null) {
  16.             System.out.println(line);
  17.         }
  18.         // 3. 释放资源
  19.         br.close();
  20.     }
  21. }

练习：文本排序

  1. import java.io.*;
  2. import java.util.HashMap;
  3. import java.util.Iterator;
  4. import java.util.Map;
  5. import java.util.Set;
  6. /*
  7.     练习：
  8.         对文本的内容进行排序
  9.         按照（1，2，3，4...)顺序排序
  10.     分析：
  11.         1. 创建一个HashMap集合对象
  12.             key:存储每行的文本序号(1,2,3...)
  13.             value:存储每行的文本
  14.         2. 创建字符缓冲输入流对象，构造方法中绑定字符输入流对象
  15.         3. 创建字符缓冲输入流对象，构造方法中绑定字符输出流对象
  16.         4. 调用字符缓冲输入流中的方法，readLine，逐行读取文本
  17.         5. 对读取到的文本进行切割，获取行中的序号和文本内容
  18.         6. 把切割好的序号和文本内容存储到HashMap集合中(key是有序的，会自动排序1,2,3..)
  19.         7. 遍历HashMap集合，获取每一个键值对
  20.         8. 把每一个键值对，拼接成一个文本行
  21.         9. 把拼接好的文本行，使用字符缓冲输入流的方法write，写入文件中
  22.         10. 释放资源
  23.  */
  24. public class Demo06Test {
  25.     public static void main(String[] args) throws IOException {
  26.         // 1. 创建HashMap集合,key：序号，value：文本内容
  27.         HashMap<String, String> map = new HashMap<>();
  28.         // 2. 创建字符缓冲输入流对象
  29.         BufferedReader br = new BufferedReader(new FileReader("itcast-code\\in.txt"));
  30.         // 3. 创建字符缓冲输入流对象
  31.         BufferedWriter bw = new BufferedWriter(new FileWriter("itcast-code\\out.txt"));
  32.         // 4. 使用字符缓冲输入流中的方法，readLine方法，读取文本内容
  33.         String line;
  34.         while ((line = br.readLine()) != null) {
  35.             // 5. 对读取到的字符串进行切割，key：序号，value：文本内容
  36.             String[] arr = line.split("\\.");
  37.             // 6. 把切割好的字符串放入到HashMap集合中
  38.             map.put(arr[0], arr[1]);
  39.         }
  40.         // 7. 遍历HashMap集合，获取键值对
  41.         Set<Map.Entry<String, String>> entrySet = map.entrySet();
  42.         // 遍历Set集合的迭代器
  43.         Iterator<Map.Entry<String, String>> it = entrySet.iterator();
  44.         while (it.hasNext()) {
  45.             Map.Entry<String, String> entry = it.next();
  46.             String key = entry.getKey();
  47.             String value = entry.getValue();
  48.             // 8. 对键值对进行拼接
  49.             line = key + "." + value;
  50.             // 9. 使用字符缓冲输出流对象，输出到文件中
  51.             bw.write(line);
  52.             // 换行
  53.             bw.newLine();
  54.         }
  55.         // 10. 释放资源
  56.         bw.close();
  57.         br.close();
  58.     }
  59. }

转换流

字符编码和字符集

字符编码

  • 编码：字符（能看懂的）--> 字节（看不懂的）。
  • 解码：字节（看不懂的）--> 字符（能看懂的）。
  • 字符编码（Character Encoding)：就是一套自然语言的字符与二进制数之间的对应规则。
    • 编码表：生活中的文字和计算机中二进制的对应规则。

字符集

  • 字符集（CharSet）：也叫编码表，是一个系统支持的所有字符的集合，包括各国家的文字、标点符号、图形符号、数字等。
  • ASCII字符集：
    • 基本的ASCII字符集，使用7位（bits）表示一个字符，共128个字符。ASCII的扩展字符集使用8位（bits）表示一个字符，共256个字符，方便支持欧洲常用字符。
  • ISO-8859-1字符集：
    • 使用单字节编码，兼容ASCII编码。
  • GBxxx字符集：
    • GB就是国标的意思，是为了显示中文而设计的一套字符集。
    • GB2312：简体中文码表。
    • GBK：最常用的中文码表，用2个字节表示一个中文。
    • GB18030：最新的中文码表，采用多字节编码，每个字可以由1、2、4个字节组成。
  • Unicode字符集
    • 万国码
    • 它最多使用4个字节的数字表达字符。有三种编码方案：UTF-8、UTF-16、UTF-32。最为常用的是UTF-8。
    • UTF-8编码：
      1. 128个US-ASCII字符，只需一个字节编码。
      2. 拉丁文等字符，需要2个字节编码。
      3. 大部分常用字（含中文），使用3个字节编码。
      4. 其他极少使用的Unicode辅助字符，使用4个字节编码。

编码引出的问题

在IDEA中，使用FileReader读取项目中的文本文件。由于IDEA的设置，都是默认的UTF-8编码，所以没有任何问题。但是当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK，就会出现乱码。

  • 示例：
  1. // 乱码问题
  2. import java.io.FileReader;
  3. import java.io.IOException;
  5. public class Test {
  6.     public static void main(String[] args) throws IOException {
  7.         FileReader fr = new FileReader("D:\\ideaproject\\itcast-code\\a.txt");
  8.         int len = 0;
  9.         while ((len = fr.read()) != -1) {
  10.             System.out.print((char)len);
  11.         }
  12.         fr.close();
  13.     }
  14. }
  15. /*
  16. 输出结果：
  17. ��ã����磡
  18.  */

转换流的原理

  • FileReader类：

    • 用来读取字符文件的便捷类。
    • 此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。
    • 要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

  • FileWriter类：

    • 来写入字符文件的便捷类。
    • 此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。
    • 要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。

OutputStreamWriter类

  • java.io.OutputStreamWriter extends Writer
  • OutputStreamWriter：是字符流通向字节流的桥梁；可使用指定的 charset 将要写入流中的字符编码成字节。(编码：把能看懂的 --> 看不懂的)

继承父类的共性成员方法

  1. void writer(int c)：写入单个字符。
  2. void writer(char[ ] cbuf)：写入字符数组。
  3. abstract void writer(char[ ] cbuf, int off, int len)：写入字符数组的一部分，off：数组的开始索引，len：写的字符个数。
  4. void writer(String str)：写入字符串。
  5. void writer(String str, int off, int len)：写入字符串的一部分，off：字符串的开始索引，len：写入字符的个数。
  6. void flush()：刷新该流的缓冲区。
  7. void close()：关闭此流，但要先刷新它。

构造方法

  • OutputStreamWriter(OutputStream out) ：创建使用默认字符编码的 OutputStreamWriter。
  • OutputStreamWriter(OutputStream out, String charsetName) ：创建使用指定字符集的 OutputStreamWriter。
  • 参数：
    • OutputStream out：字节输出流，可以用来写转换之后的字节到文件中。
    • String charsetName：指定编码表的名称，不区分大小写，可以是：utf-8 / UTF-8，gbk / GBK，...。不指定，默认使用 utf-8。

使用步骤：

  1. 创建OutputStreamWriter对象，构造方法中传递字节输出流对象和指定编码表名称。
  2. 使用OutputStreamWriter对象中的方法 writer，把字符转换为字节，存储在缓冲区中（编码）。
  3. 使用OutputStreamWriter对象中的方法 flush，把内存缓冲区中的字节刷新到文件中（使用字节流写的过程）。
  4. 释放资源。
  • 示例：
  1. import java.io.FileOutputStream;
  2. import java.io.IOException;
  3. import java.io.OutputStreamWriter;
  5. public class Demo01OutputStreamWriter {
  6.     public static void main(String[] args) throws IOException {
  7.         // write_utf_8();
  8.         write_gbk();
  10.     }
  12.     private static void write_gbk() throws IOException {
  13.        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("itcast-code\\gbk.txt"), "gbk");
  14.        osw.write("你好"); // 3个字节
  15.        osw.flush();
  16.        osw.close();
  17.     }
  19.     private static void write_utf_8() throws IOException {
  20.         // 1. 创建OutputStreamWriter对象，构造方法中传递字节输出流对象和指定编码表名称
  21.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("itcast-code\\utf_8.txt"), "utf-8");
  22.         // 2. 使用OutputStreamWriter对象中的方法，writer，把字符转换成字节，存储在缓冲区中。（编码）
  23.         osw.write("你好"); // 2个字节
  24.         // 3. 调用 flush方法，刷新数据到文件中、
  25.         osw.flush();
  26.         // 4. 释放资源
  27.         osw.close();
  28.     }
  29. }

InputStreamReader类

  • java.InputStreamReader extends Reader
  • InputStreamReader：是字节流通向字符流的桥梁；它使用指定的 charset 读取字节并将其解码为字符（解码：把看不懂的 --> 能看懂的）。

继承自父类的共性方法

  1. int read()：读取单个字符并返回。
  2. int read(char[ ] cbuf)：一次读取多个字符，将字符读入数组。
  3. void close()：关闭该流并释放与之关联的所有资源。

构造方法

  • InputStreamReader(InputStream in) ：创建一个使用默认字符集的 InputStreamReader。
  • InputStreamReader(InputStream in, String charsetName) ：创建使用指定字符集的 InputStreamReader
  • 参数：
    • InputStream in：字节输入流，用来读取文件中保存的字节。
    • String charsetName：指定的编码表名称，不区分大小写，可以是：utf-8 / UTF-8，gbk / GBK，...。不指定，默认使用 utf-8。

使用步骤：

  1. 创建InputStreamReader对象，构造方法中传递字节输入流对象和指定编码表名称。
  2. 使用InputStreamReader对象中的方法，read，读取文件。
  3. 释放资源。

注意事项：

构造方法中传递的编码表名称要和文件的编码表相同，否则会产生乱码。

  • 示例
  1. import java.io.FileInputStream;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  5. public class Demo03InputStreamReader {
  6.     public static void main(String[] args) throws IOException {
  7.         // read_utf_8();
  8.         read_gbk();
  10.     }
  12.     private static void read_gbk() throws IOException{
  13.         // 1.创建InputStreamReader对象，构造方法中传递字节输入流对象和指定的编码表名称
  14.         InputStreamReader isr = new InputStreamReader(new FileInputStream("itcast-code\\utf_8.txt"), "gbk");
  15.         // 2.使用InputStreamReadr中的方法，read，读取文件。
  16.         int len = 0; // 记录读取到字符的有效个数
  17.         // 使用字符数组缓冲读取到的多个字符
  18.         char[] cs = new char[1024];
  19.         while ((len = isr.read(cs)) != -1) {
  20.             System.out.println(new String(cs, 0, len));
  21.         }
  22.         // 3.释放资源
  23.         isr.close();
  24.     }
  26.     private static void read_utf_8() throws IOException {
  27.         // 1.创建InputStreamReader对象，构造方法中传递字节输入流对象和指定的编码表名称
  28.         InputStreamReader isr = new InputStreamReader(new FileInputStream("itcast-code\\utf_8.txt"));
  29.         // 2.使用InputStreamReadr中的方法，read，读取文件。
  30.         int len = 0; // 记录读取到字符的有效个数
  31.         // 使用字符数组缓冲读取到的多个字符
  32.         char[] cs = new char[1024];
  33.         while ((len = isr.read(cs)) != -1) {
  34.             System.out.println(new String(cs, 0, len));
  35.         }
  36.         // 3.释放资源
  37.         isr.close();
  38.     }
  39. }

练习：转换文件编码

  1. import java.io.*;
  3. /*
  4. 练习：转换文件编码
  5.     将gbk编码的文件，转换为utf-8编码的文件。
  6. 分析：
  7.     1.创建InputStreamReader对象，构造方法中传递字节输入流对象和指定gbk编码
  8.     2.创建OutputStreamWriter对象，构造方法中传递字节输出流对象和指定utf-8编码
  9.     3.使用InputStreamReader对象的方法 read，读取数据到缓冲区中
  10.     4.使用OutputStreamWriter对象的方法 writer，将数据写入到文件中
  11.     5.释放资源
  12.  */
  13. public class Demo02Test {
  14.     public static void main(String[] args) throws IOException {
  15.         InputStreamReader isr = new InputStreamReader(new FileInputStream("itcast-code\\gbk.txt"),"gbk");
  16.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("itcast-code\\utf_8.txt"), "utf-8");
  17.         int len = 0;
  18.         while ((len = isr.read()) != -1) {
  19.             osw.write(len);
  20.         }
  21.         osw.close();
  22.         isr.close();
  24.     }
  25. }

序列化&反序列化

序列化&反序列化概述

ObjectOutputStream类

  • java.io.ObjectOutputStream extends OutputStream
  • ObjectOutputStream：对象的序列化流
  • 作用：把对象以流的方式写入到文件中保存。

构造方法

  • ObjectOutputStream(OutputStream out)：创建写入指定 OutputStream 的 ObjectOutputStream。
  • 参数：
    • OutputStream out：字节输出流。

特有的成员方法

  • void writeObject(Object obj) ：将指定的对象写入 ObjectOutputStream。

使用步骤：

  1. 创建 ObjectOutputStream对象，构造方法中传递字节输出流。
  2. 使用 ObjectOutputStream对象中的方法，writeObject，把对象写入到文件中。
  3. 释放资源。

示例

  • Person.java
  1. import java.io.Serializable;
  2. /*
  3.     序列化和反序列化的时候，会抛出 NotSerializableException没有序列化异常
  4.     类通过实现 java.io.Serializable 接口以启用其序列化功能。
  5.     未实现此接口的类将无法使其任何状态序列化或反序列化。
  6.     Serializable接口也叫标记型接口
  7.         要进行序列化和反序列化的类，必须实现 Serializable接口，就会给类添加一个标记
  8.         当我们进行序列化和反序列化的时候，就会检测类上是否有这个标记
  9.             有：可以序列化和反序列化
  10.             没有：就会抛出 NotSerializableException异常
  11.  */
  12. public class Person implements Serializable {
  13.     private String name;
  14.     private int age;
  16.     public Person() {
  17.     }
  19.     public Person(String name, int age) {
  20.         this.name = name;
  21.         this.age = age;
  22.     }
  24.     @Override
  25.     public String toString() {
  26.         return "Person{" +
  27.                 "name='" + name + '\'' +
  28.                 ", age=" + age +
  29.                 '}';
  30.     }
  32.     public String getName() {
  33.         return name;
  34.     }
  36.     public void setName(String name) {
  37.         this.name = name;
  38.     }
  40.     public int getAge() {
  41.         return age;
  42.     }
  44.     public void setAge(int age) {
  45.         this.age = age;
  46.     }
  47. }
  • Demo01ObjectOutputStream.java
  1. import java.io.FileOutputStream;
  2. import java.io.IOException;
  3. import java.io.ObjectOutputStream;
  5. public class Demo01ObjectOutputStream {
  6.     public static void main(String[] args) throws IOException {
  7.         Person one = new Person("小美女", 18);
  8.         // 1.创建ObjectOutputSream对象，构造方法中传递字节输出流
  9.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("itcast-code\\person.txt"));
  10.         // 2.使用ObjectOutputstream中的方法，writerObject，将对象写入到文件中
  11.         oos.writeObject(one);
  12.         // 3.释放资源
  13.         oos.close();
  14.     }
  15. }

ObjectInputStream类

  • java.io.ObjectInputStream extends InputStream
  • ObjectInputStream：对象的反序列化流。
  • 作用：把文件中保存的对象，以流的方式读取出来使用。

构造方法

  • ObjectInputStream(InputStream in) ：创建从指定 InputStream 读取的 ObjectInputStream。
  • 参数：
    • InputStream in：字节输入流

特有的成员方法

  • Object readObject() ：从 ObjectInputStream 读取对象。

使用步骤：

  1. 创建ObjectInputStream对象，构造方法中传递字节输入流。
  2. 使用ObjectInputStream对象中的方法 readObject读取保存对象的文件。
  3. 释放资源。

注意事项：

readObject方法声明抛出了 ClassNotFoundException（class文件找不到异常）

当不存在对象的 class文件时抛出此异常。

反序列化的前提：

  1. 类必须实现 Serializable接口
  2. 必须存在类对应的 class文件
  • 示例
  1. import java.io.FileInputStream;
  2. import java.io.IOException;
  3. import java.io.ObjectInputStream;
  5. public class Demo03ObjectInputStream {
  6.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  7.         // 1.创建ObjectInputStream对象，构造方法中传递字节输入流
  8.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("itcast-code\\person.txt"));
  9.         // 2.使用ObjectInputStream中的方法，readObject,读取文件中保存的对象
  10.         Object o = ois.readObject();
  11.         System.out.println(o);
  12.         Person one = (Person)o;
  13.         System.out.println(one.getName()+one.getAge());
  14.         // 3.释放资源
  15.         ois.close();
  16.     }
  17. }

transient关键字

  • static关键字：静态关键字

    • 静态优于非静态加载到内存中（静态优先于对象进入到内存中）。
    • 被 static修饰的成员变量不能被序列化，序列化的都是对象。
  1. private static int age;
  2. oos.writeObject(new Person("小美女", 18));
  3. Object o = ois.readObject();
  4. Person{name='小美女', age=0}
  • transient关键字：瞬态关键字

    • 被 transien修饰的成员变量，不能被序列化。
  1. private transient int age;
  2. oos.writeObject(new Person("小美女", 18));
  3. Object o = ois.readObject();
  4. Person{name='小美女', age=0}

InvalidClassException异常

  • 编译器（javac.exe）会把 Person.java文件编译成生成 Person.class 文件，Person类实现了 Serializable接口，就会根据类的定义，给 Person.class文件添加一个序列号（serialVersionUID）。

  • 反序列化的时候，会使用Person.class文件中的序列号和Person.txt文件中的序列号进行比较，如果是一样的，则反序列化成功；如果不一样，则抛出序列化冲突异常：InvalidClassException。

  • 修改了类的定义，那么就会给 Person.class 文件重新编译生成一个新的序列号（serialVersionUID）。

  • 问题：

    • 每次修改了类的定义，都会给class文件重新生成一个新的序列号。

  • 解决方案：

    • 无论是否对类的定义进行修改，都不重新生成新的序列号。
    • 可以手动给类添加一个序列号。

  • 格式在 Serializable接口内有规定：

    • 可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：
    • static final long serialVersionUID = 42L;

练习：序列化集合

  1. import java.io.*;
  2. import java.util.ArrayList;
  4. /*
  5. 练习：序列化集合
  6.     当我们想在文件中保存多个对象的时候，可以把多个对象存储到一个集合中
  7.     对集合进行序列化和反序列化
  8. 分析：
  9.     1.定义一个存储Person对象的ArrayList集合
  10.     2.往ArrayList集合中添加多个对象
  11.     3.创建一个序列化ObjectOutputStream对象
  12.     4.使用ObjectOutputStream对象中的 writeObject方法，对集合进行序列化
  13.     5.创建一个反序列化ObjectInputStream对象
  14.     6.使用ObjectInputStream对象中的方法 readObject方法，读取文件中保存的集合
  15.     7.把 Object类型的集合强转为 ArrayList类型
  16.     8.遍历ArrayList集合
  17.     9.释放资源
  18.  */
  19. public class Demo02Pracitse {
  20.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  21.         // 创建集合
  22.         ArrayList<Person> list = new ArrayList<>();
  23.         // 添加元素
  24.         list.add(new Person("周元", 20));
  25.         list.add(new Person("夭夭", 21));
  26.         list.add(new Person("苏幼薇", 19));
  27.         // 创建序列化流对象
  28.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("itcast-code\\list.txt"));
  29.         // 调用 writeObject方法，将集合写入
  30.         oos.writeObject(list);
  31.         // 创建反序列化流对象
  32.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("itcast-code\\list.txt"));
  33.         // 调用 readObject方法，读取集合
  34.         Object o = ois.readObject();
  35.         // 将 Object类型强转为 Arraylist类型
  36.         ArrayList<Person> personArrayList = (ArrayList<Person>)o;
  37.         // 遍历集合
  38.         for (Person p : personArrayList) {
  39.             System.out.println(p);
  40.         }
  41.         // 释放资源
  42.         oos.close();
  43.         ois.close();
  44.     }
  45. }

打印流

概述

  • java.io.PrintStream extends FilterOutputStream extends OutputStream
  • java.io.PrintStream：打印流
  • PrintStream：为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
  • PrintStream特点：
    1. 只负责数据的输出，不负责数据的读取。
    2. 与其他输出流不同，PrintStream 永远不会抛出 IOException，但会抛出 FileNotFoundException。
    3. 有特有的方法：print，println
      • void print(任意类型的值)
      • void println(任意类型的值并换行)

构造方法

  • PrintStream(File file) ：创建具有指定文件且不带自动行刷新的新打印流。
  • PrintStream(OutputStream out) ：创建新的打印流。
  • PrintStream(String fileName) ：创建具有指定文件名称且不带自动行刷新的新打印流。

继承自父类的共性方法

  1. public void close()：关闭此输出流并释放与此流相联的任何系统资源。
  2. public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出。
  3. public void write(byte[] b)：将b.length字节从指定的字节数组写入此输出流。
  4. public void write(byte[] b, int off, int len)：从指定的字节数组写入 len字节，从偏移量 off开始输出至此输出流。
  5. public abstract void write(int b)：将指定的字节输出流。

注意事项：

  1. 如果使用继承自父类的 write方法写数据，那么查看数据的时候，会查询编码表：97 --> a。
  2. 如果使用自己特有的方法 print / println方法写数据，那么写的数据会原样输出：97 --> 97。
  1. import java.io.FileNotFoundException;
  2. import java.io.PrintStream;
  4. public class Demo01PrintStream {
  5.     public static void main(String[] args) throws FileNotFoundException {
  6.         // 1.创建PrintStream对象，构造方法中绑定输出的目的地
  7.         PrintStream ps = new PrintStream("itcast-code\\print.txt");
  8.         // 2.调用父类的 write方法
  9.         ps.write(48); // 0
  10.         // 2.调用自己的 print / println 方法
  11.         ps.println();
  12.         ps.println(97); // 97
  13.         // 3.释放资源
  14.         ps.close();
  15.     }
  16. }

改变输出流的流向

  • 可以改变输出语句的目的地（打印流的流向）。
  • 输出语句，默认在控制台输出。
  • 使用 System.setOut 方法该变输出语句的目的地，目的地修改为PrintStream构造方法中传递的目的地。
  • static void setOut(PrintStream out) ：重新分配“标准”输出流。
  1. import java.io.FileNotFoundException;
  2. import java.io.PrintStream;
  4. public class Demo02PrintStream {
  5.     public static void main(String[] args) throws FileNotFoundException {
  6.         PrintStream ps = new PrintStream("itcast-code\\print.txt");
  7.         // 在控制台输出
  8.         System.out.println("我在控制台输出，哈哈哈");
  9.         // 改变输出流的流向
  10.         System.setOut(ps);
  11.         // 这条语句在文件中原样输出
  12.         System.out.println("我在print.txt中输出，呵呵呵");
  13.         ps.close();
  14.     }
  15. }

Java IO流(二)的更多相关文章

  1. 《二》Java IO 流的分类介绍

    一.根据流向分为输入流和输出流: 注意输入流和输出流是相对于程序而言的. 输出:把程序(内存)中的内容输出到磁盘.光盘等存储设备中        输入:读取外部数据(磁盘.光盘等存储设备的数据)到程序 ...

  2. Java IO流详解（二）——File类

    在上一章博客中简单的介绍了Java IO流的一些特征.也就是对文件的输入输出,既然至始至终都离不开文件,所以Java IO流的使用得从File这个类讲起. File类的描述:File类是文件和目录路径 ...

  3. Java IO流题库

    一.    填空题 Java IO流可以分为   节点流   和处理流两大类,其中前者处于IO操作的第一线,所有操作必须通过他们进行. 输入流的唯一目的是提供通往数据的通道,程序可以通过这个通道读取数 ...

  4. JAVA.IO流学习笔记

    一.java.io 的描述 通过数据流.序列化和文件系统提供系统输入和输出.IO流用来处理设备之间的数据传输 二.流 流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数 ...

  5. Java IO流学习

    Java IO流学习 Java流操作有关的类或接口: Java流类图结构: 流的概念和作用 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是 ...

  6. java IO流 总结

    [-] 1什么是IO 2数据流的基本概念 1 数据流 2 输入流Input  Stream 3 输出流 数据流分类 3 标准IO 命令行参数 标准输入输出数据流 4javaIO层次体系结构 5 非流式 ...

  7. 学习笔记-java IO流总结 转载

    1.什么是IO Java中I/O操作主要是指使用Java进行输入,输出操作. Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列.Java的I/O流提供了读 ...

  8. java IO流读取图片供前台显示

    最近项目中需要用到IO流来读取图片以提供前台页面展示,由于以前一直是用url路径的方式进行图片展示,一听说要项目要用IO流读取图片感觉好复杂一样,但任务下达下来了,做为程序员只有选择去执行喽,于是找了 ...

  9. Java:IO流与文件基础

    Java:IO流与文件基础 说明: 本章内容将会持续更新,大家可以关注一下并给我提供建议,谢谢啦. 走进流 什么是流 流:从源到目的地的字节的有序序列. 在Java中,可以从其中读取一个字节序列的对象 ...

随机推荐

  1. 搭建WEB、NFS共享、sersync实时同步以及全网定时备份服务流程

    本次实验的主要目的: 1.搭建web服务,使用nfs服务共享的/data目录挂载到web站点目录上. 2.nfs服务器与backup服务器使用sersync实时同步/data目录中的文件. 3.bac ...

  2. lambda表达式，及lambda简化过程

    lambda表达式(jdk8特性) 1.为什么要用lambda表达式 原因:因为我们有时候需要用到很多类,但是,这些类我们只用一次或者两次,所以我们用匿名内部类,但是匿名内部类多了还是很麻烦,所以用l ...

  3. AJ学IOS（37）UI之CALayer

    AJ分享,必须精品 CALayer 在iOS中,你能看得见摸得着的东西基本上都是UIView,比如一个按钮.一个文本标签.一个文本输入框.一个图标等等,这些都是UIView. 其实UIView之所以能 ...

  4. 【Java】WrapperClass 包装类

    什么是包装类? 写写我的想法 就是对于对象和基本类型的无法匹配和强转,基本类型在面向对象的实例类型中,反而成了个特殊的数据类型的存在 在一些特定的情况,我们希望通过对象的方式去处理数据,但是基本类型的 ...

  5. 化繁为简，弱监督目标定位领域的新SOTA - 伪监督目标定位方法(PSOL) | CVPR 2020

    论文提出伪监督目标定位方法(PSOL)来解决目前弱监督目标定位方法的问题,该方法将定位与分类分开成两个独立的网络,然后在训练集上使用Deep descriptor transformation(DDT ...

  6. day7作业

    # day7作业 # 1. 使用while循环输出1 2 3 4 5 6 8 9 10 count = 1 while count < 11: if count == 7: count += 1 ...

  7. Java SE —— 专栏总集篇

    前言: Java 语言,是相对于其他语言而言,门槛低,而且功能还强大的一门编程语言,本人十分看好这一门语言,但是,它也是有深度的,看过本人的<数据结构与算法>专栏的同学们有福了,因为本人在 ...

  8. 处理时间的类 —— System类、Date类 、SimpleDateFormat类 与 Calendar类

    在我们以往的编程中,就有过通过运行前和运行后时间差来判断时间复杂度的例子,再扯得远一点,我们在C语言中制造随机数的操作,也要用到有关时间的函数.而且,在我们未来的编程中,也会时不时要用到能够读取当前时 ...

  9. [javascript]各种页面定时跳转(倒计时跳转)代码总结

    (1)使用setTimeout函数实现定时跳转(如下代码要写在body区域内) <script type="text/javascript"> //3秒钟之后跳转到指定 ...

  10. 百度paddlepaddle学习体会

    一个偶然从微信公众号中刷到了<python小白逆袭A1大神>的文章,让我不经意的邂逅了飞桨(paddlepaddle),通过加入飞桨训练营一周的学习.实践,对飞桨有了很多的了解(飞桨官网: ...