一、流分类

  1. 根据流的数据单位(类型) 可以分为 字节流 8bit(byte)、字符流 16bit(char)
    1. 字节流输入流 inputStream
    2. 字节流输出流 outPutStream
    3. 字符流输入流 reader
    4. 字符流输出流 writer
  2. 根据流的流向 可以分为 输入流、输出流
  3. 根据流的角色 可以分为节点流、处理流
    1. 直接作用在数据上的流称为节点流
    2. 包裹节点流的流称为处理流

image.png

二、重点掌握流

分类 字节输入流 字节输出流 字符输入流 字符输出流
抽象基类 InputStream OutputStream Reader Writer
访问文件 FileInputStream FileOutputStream FileReader FileWriter
访问数组 ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter
访问管道 PipedInputStream PipedOutputStream PipedReader PipedWriter
访问字符串

|

| StringReader | StringWriter | | 缓冲流 | BufferedInputStream | BufferedOutputStream | BufferedReader | BufferedWriter | | 转换流 |

|

| InputStreamReader | OutputStreamWriter | | 对象流 | ObjectInputStream | ObjectOutputStream |

|

| |

| FilterInputStream | FilterOutputStream | FilterReader | FilterWriter | | 打印流 |

|
PrintStream |

|
PrintWirter | | 推回输入流 |

|

|

|

| | 特殊流 |

|

|

|

|

  2. /**
  3.  * @author:LYY 创建时间:2022/5/9
  4.  * io流操作
  5.  */
  6. public class FileReaderTest {
  9.     /**
  10.      * 对象流
  11.      * 序列化对象和反序列化
  12.      * 当person对象序列化到person.dat文件中 并实现反序列化
  13.      */
  14.     @Test
  15.     public void objectInputStreamAndObjectOutputStreamTest() {
  16.         // 1. 实例化File文件对象
  17.         File file = new File("person.dat");
  19.         // 要被序列化的对象
  20.         Person person = new Person("张胜男", 15);
  21.         // 2. 创建序列化对象(输出对象流:ObjectOutputStream)
  22.         ObjectOutputStream oos = null;
  23.         // 2. 创建反序列化对象(输入对象流:ObjectInputStream)
  24.         ObjectInputStream ois = null;
  26.         try {
  27.             // 3. 序列化对象(将对象输出到硬盘)
  28.             oos = new ObjectOutputStream(new FileOutputStream(file));
  29.             oos.writeObject(person);
  30.             // 清空缓冲空间
  31.             oos.flush();
  32.             // 4. 反序列化对象(将硬盘中保存的对象重新获取到内存)
  33.             ois = new ObjectInputStream(new FileInputStream(file));
  34.             Object object = ois.readObject();
  35.             System.out.println(object);
  36.         } catch (IOException e) {
  37.             e.printStackTrace();
  38.         } catch (ClassNotFoundException e) {
  39.             e.printStackTrace();
  40.         } finally {
  41.             // 关闭反序列化对象
  42.             if (ois != null) {
  43.                 try {
  44.                     ois.close();
  45.                 } catch (IOException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.             }
  49.             // 关闭序列化对象
  50.             if (oos != null) {
  51.                 try {
  52.                     oos.close();
  53.                 } catch (IOException e) {
  54.                     e.printStackTrace();
  55.                 }
  56.             }
  57.         }
  58.     }
  60.     /**
  61.      * 标准输入输出流和打印流
  62.      */
  63.     @Test
  64.     public void systemTest() {
  66.         // 标准输入流 从键盘输入
  67.         InputStream in = System.in;
  68.         // 标准输出流 默认输出到控台
  69.         PrintStream out = System.out;
  70.         PrintWriter printWriter = null;
  71.         try {
  72.             // 创建打印流
  73.             //printWriter = new PrintWriter(new FileWriter(new File("hello.txt")));
  74.             FileOutputStream fileOutputStream = new FileOutputStream("hello.txt");
  75.             // 重写标准输出流
  76.            // printWriter.print("你好!");
  77.             // 重新设置打印流
  78.             System.setOut(new PrintStream(fileOutputStream));
  79.             System.out.print("boolean");
  80.         } catch (IOException e) {
  81.             e.printStackTrace();
  82.         } finally {
  83.             //printWriter.close();
  84.         }
  86.     }
  87.     /**
  88.      * 转换流读取文件写出文件
  89.      * 1. 读取文件时 读取文件的转换流编码格式必须与文件格式一致
  90.      * 2. 写出文件时 写出文件的转换流可以自定义文件编码 不指定则默认系统设置的编码格式
  91.      */
  92.     @Test
  93.     public void inputStreamReaderAndOutputStreamWriterTest() {
  94.         // 1. 实例化File对象
  95.         File inFile = new File("hello.txt");
  96.         File outFile = new File("hello1.txt");
  98.         // 2. 创建转换流对象
  99.         // 将读入的字节流 转为 字符流
  100.         InputStreamReader isr = null;
  101.         // 将写出的字符流 转为 字节流
  102.         OutputStreamWriter osw = null;
  103.         try {
  104.             // 3. 实例化转换流对象
  105.             // 实例化输入转换流
  106.             isr = new InputStreamReader(new FileInputStream(inFile));
  107.             // 实例输出转换流
  108.             // osw = new OutputStreamWriter(new FileOutputStream(outFile));
  109.             // 可以指定写出文件的编码格式
  110.             osw = new OutputStreamWriter(new FileOutputStream(outFile),"gbk");
  111.             char[] chars = new char[1024];
  112.             int len;
  113.             // 读取文件
  114.             while ((len = isr.read(chars)) != -1) {
  115.                 // 写出文件
  116.                 osw.write(chars, 0, len);
  117.             }
  118.         } catch (FileNotFoundException e) {
  119.             e.printStackTrace();
  120.         } catch (IOException e) {
  121.             e.printStackTrace();
  122.         } finally {
  123.             // 4. 关闭转换流
  124.             if (osw != null) {
  125.                 try {
  126.                     osw.close();
  127.                 } catch (IOException e) {
  128.                     e.printStackTrace();
  129.                 }
  130.             }
  131.             if (isr != null) {
  132.                 try {
  133.                     isr.close();
  134.                 } catch (IOException e) {
  135.                     e.printStackTrace();
  136.                 }
  137.             }
  138.         }
  140.     }
  142.     /**
  143.      * 使用缓冲流(BufferedInputStream)实现文件的复制
  144.      */
  145.     @Test
  146.     public void bufferedInputStreamAndBufferedOutputStreamTest() {
  147.         // 1. 实例化file对象
  148.         // 实例化要读取的文件
  149.         File inputStreamJpg = new File("preview.jpg");
  150.         String user = System.getProperty("user.name");
  151.         // 实例化要输出的文件
  152.         File outputStream = new File("C:\\Users\\" + user + "\\Desktop",inputStreamJpg.getName());
  154.         // 2. 实例化输入流(FileInputStream)和输出流(FileOutputStream)
  155.         FileInputStream input = null;
  156.         FileOutputStream output = null;
  157.         // 3. 实例化处理流(缓冲流)
  158.         // 实例化输入流
  159.         BufferedInputStream bufferedInputStream = null;
  160.         // 实例化输出流
  161.         BufferedOutputStream bufferedOutputStream = null;
  162.         try {
  163.             // 赋值输入节点流
  164.             input = new FileInputStream(inputStreamJpg);
  165.             // 赋值输出节点流
  166.             output = new FileOutputStream(outputStream);
  167.             // 赋值输入缓冲流
  168.             bufferedInputStream = new BufferedInputStream(input);
  169.             // 赋值输出流缓冲流
  170.             bufferedOutputStream = new BufferedOutputStream(output);
  171.             byte[] bytes = new byte[1024];
  172.             // 记录每次读取的字节个数
  173.             int len;
  174.             while ((len = bufferedInputStream.read(bytes)) != -1) {
  175.                 // 写出文件到硬盘
  176.                 bufferedOutputStream.write(bytes,0,len);
  177.             }
  178.         } catch (FileNotFoundException e) {
  179.             e.printStackTrace();
  180.         } catch (IOException e) {
  181.             e.printStackTrace();
  182.         } finally {
  183.             // 4. 关闭缓冲输出流和缓冲输入流
  184.             // 关闭处理流的同时 节点流也会关闭
  185.             if (bufferedOutputStream != null) {
  186.                 try {
  187.                     bufferedOutputStream.close();
  188.                 } catch (IOException e) {
  189.                     e.printStackTrace();
  190.                 }
  191.             }
  193.             if (bufferedInputStream != null) {
  194.                 try {
  195.                     bufferedInputStream.close();
  196.                 } catch (IOException e) {
  197.                     e.printStackTrace();
  198.                 }
  199.             }
  201.         }
  202.     }
  203.     /**
  204.      * 使用FileInputStream和FileOutputStream实现文件的复制
  205.      */
  206.     @Test
  207.     public void fileInputStreamAdnFileOutputStreamTest() {
  208.         // 1. 实例化file对象
  209.         // 实例化要读取的文件
  210.         File inputStreamJpg = new File("preview.jpg");
  211.         String user = System.getProperty("user.name");
  212.         System.out.println(user);
  213.         // 实例化要输出的文件
  214.         File outputStream = new File("C:\\Users\\" + user + "\\Desktop",inputStreamJpg.getName());
  215.         System.out.println(outputStream);
  217.         // 2. 实例化输入流(FileInputStream)和输出流(FileOutputStream)
  218.         FileInputStream input = null;
  219.         FileOutputStream output = null;
  220.         try {
  221.             // 实例化输入流
  222.             input = new FileInputStream(inputStreamJpg);
  223.             // 实例化输出流
  224.             output = new FileOutputStream(outputStream);
  225.             byte[] bytes = new byte[100];
  226.             // 记录每次读取的字节个数
  227.             int len;
  228.             while ((len = input.read(bytes)) != -1) {
  229.                 // 写出文件到硬盘
  230.                 output.write(bytes,0,len);
  231.             }
  232.         } catch (FileNotFoundException e) {
  233.             e.printStackTrace();
  234.         } catch (IOException e) {
  235.             e.printStackTrace();
  236.         } finally {
  237.             // 4. 关闭输出流和输入流
  238.             try {
  239.                 if (output != null) {
  240.                     output.close();
  241.                 }
  242.             } catch (IOException e) {
  243.                 e.printStackTrace();
  244.             }
  245.             try {
  246.                 if (input != null) {
  247.                     input.close();
  248.                 }
  249.             } catch (IOException e) {
  250.                 e.printStackTrace();
  251.             }
  252.         }
  253.     }
  255.     /**
  256.      * 将内存中的数据写到硬盘中
  257.      */
  258.     @Test
  259.     public void fileWriterTest() {
  260.         // 1. 实例化File对象
  261.         File file = new File("hello.txt");
  262.         FileWriter writer = null;
  263.         try {
  264.             // 2. 实例化输出流FileWriter对象
  265.             // 默认文件不存在 输出流自动创建 若文件已经存在 则覆盖 可以通过设置关闭是否覆盖已存在的文件
  266.             writer = new FileWriter(file);
  267.             // 3. 调用输出方法 将数据写入到硬盘中
  268.             writer.write("你好,世界!\n");
  269.             writer.write("hello world!");
  271.         } catch (Exception e) {
  272.             e.printStackTrace();
  273.         } finally {
  274.             // 4. 关闭
  275.             try {
  276.                 writer.close();
  277.             } catch (IOException e) {
  278.                 e.printStackTrace();
  279.             }
  280.         }
  282.     }
  284.     /**
  285.      * 读取文件到内存中
  286.      */
  287.     @Test
  288.     public void readerTest02() {
  290.         // 1. 创建要的读取的file对象
  291.         File fileJpg = new File("preview.jpg");
  292.         File fileTxt = new File("preview.txt");
  294.         // 2. 创建对应流对象
  295.         FileInputStream fileInputStream = null;
  296.         FileReader fileReader = null;
  297.         try {
  298.             // 实例化流对象
  299.             fileInputStream = new FileInputStream(fileJpg);
  300.             fileReader = new FileReader(fileTxt);
  302.             char[] chars = new char[5];
  303.             int c;
  305.             // fileReader.read(chars) 该方法返回读取的字符数 末尾返回-1
  306.             while ((c = fileReader.read(chars)) != -1) {
  308.                 // 正确的
  309.                 // String str = new String(chars, 0, c);
  310.                 // System.out.print(str);
  312.                 // 错误的
  313.                 // for (char aChar : chars) {
  314.                 //     System.out.print(aChar);
  315.                 // }
  317.                 // 正确的
  318.                 for (int i = 0; i < c; i++) {
  319.                     System.out.print(chars[i]);
  320.                 }
  321.             }
  322.         } catch (FileNotFoundException e) {
  323.             e.printStackTrace();
  324.         } catch (IOException e) {
  325.             e.printStackTrace();
  326.         } finally {
  327.             // 4. 关闭对应流对象
  328.             try {
  329.                 if (fileInputStream != null) {
  330.                     fileInputStream.close();
  331.                 }
  332.                 if (fileReader != null) {
  333.                     fileReader.close();
  334.                 }
  335.             } catch (IOException e) {
  336.                 e.printStackTrace();
  337.             }
  338.         }
  340.     }
  342.     /**
  343.      * 读取文件到内存中
  344.      */
  345.     @Test
  346.     public void readerTest01() {
  348.         // 1. 创建要的读取的file对象
  349.         File fileJpg = new File("preview.jpg");
  350.         File fileTxt = new File("preview.txt");
  352.         // 2. 创建对应流对象
  353.         FileInputStream fileInputStream = null;
  354.         FileReader fileReader = null;
  355.         try {
  356.             // 实例化流对象
  357.             fileInputStream = new FileInputStream(fileJpg);
  358.             fileReader = new FileReader(fileTxt);
  360.             int c;
  361.             while ((c = fileReader.read()) != -1) {
  362.                 System.out.print((char)c);
  363.             }
  364.         } catch (FileNotFoundException e) {
  365.             e.printStackTrace();
  366.         } catch (IOException e) {
  367.             e.printStackTrace();
  368.         } finally {
  369.             // 4. 关闭对应流对象
  370.             try {
  371.                 if (fileInputStream != null) {
  372.                     fileInputStream.close();
  373.                 }
  374.                 if (fileReader != null) {
  375.                     fileReader.close();
  376.                 }
  377.             } catch (IOException e) {
  378.                 e.printStackTrace();
  379.             }
  380.         }
  382.     }
  383. }

```