1.字节输出流

输出流：

OutputStream(抽象类)
FileOutputStream(基本输出流)
构造方法：
public FileOutputStream(String name)：创建输出流操作的目标
public FileOutputStream(String name,boolean append)：append为true代表每次写入都向文件末尾追加,为false则每次都是覆盖写入
操作方法：
write(int n)：输出一个字节；
write(byte[] b)：输出一个字节数组；
write(byte[] b, int off , int len)：输出字节数组的一部分；
close()： 释放IO占用的windows底层资源；

public void write(byte[] b) 写出一个字节数组的字节

  • 输出流的源代码实现:如果输出时没有该文件,则会先创建该文件,再输出数据
  • 默认的写出是覆盖掉了文件以前的内容,如果想每次运行程序写出数据不覆盖之前的内容,使用特定的构造方法
  • public FileOutputStream(String name,boolean append) append参数:是否追加数据

  • 在FileOutputStream的构造方法当中,指定的io资源可以是文件对象,也可以是文件路径,其本质是相同的.
  • 一般情况下直接使用给予文件路径的方式创建IO流对象,因为源代码中会自动帮助我们创建File对象. ```java package com.igeek_01;

import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.HashSet; import java.util.Set;

/**

  • @author Lynn

  • @create 2020-12-11-10:20 / public class FileOutPutStreamDemo { /public static void main(String[] args) throws IOException {

    1.  //创建流对象，绑定io数据
    2.  FileOutputStream fos=new FileOutputStream("test.txt");
    3.  //向文件中写入数据

    // fos.write(0b01100001);//当前输入的是一个a的二进制字节码 // fos.write(98);

    1.  fos.write('a');
    3.  //关闭流
    4.  fos.close();

    }*/

    /*public static void main(String[] args) throws IOException {

    1.  //创建一个流对象
    2.  FileOutputStream fos=new FileOutputStream("test.txt",true);//支持追加
    3.  //写入数据
    4.  byte[] b={97,98,99};
    5.  fos.write(b);
    7.  //int类型的数组不支持，因为方法的参数中只传入byte类型的数组
    8.  *//*int[] i={100,101,102};
    9.  fos.write(i);*//*
    11.  fos.close();

    }*/ } ```

    字节输入流

    输入流：

    InputStream(抽象类)：
    FileInputStream(基本输入流)
    构造方法：
    public FileInputStream(String name)
    操作方法：
    int read()：读取一个字节, 返回的是字节内容本身，读取到末尾返回-1
    int read(byte[] b)：读取一个字节数组
    close()：释放IO占用的系统底层资源 ```java package com.igeek_02;

import java.io.FileInputStream; import java.io.IOException;

/**

  • @author Lynn

  • @create 2020-12-11-10:34 */ public class InputStreamDemo { public static void main(String[] args) throws IOException {

    1.  //创建文件输入流--保证文件必须存在
    2.  FileInputStream fis=new FileInputStream("test.txt");
    3.  /*//读取
    4.  int c= fis.read();
    5.  System.out.println(c);//97
    6.  System.out.println(Integer.toBinaryString(c));//1100001--97的二进制换算*/
    8.  /*//逐个读取--底层有一个指针，进行逐个读取
    9.  System.out.println(fis.read());//97
    10.  System.out.println(fis.read());//97
    11.  System.out.println(fis.read());//98
    12.  System.out.println(fis.read());//99
    13.  System.out.println(fis.read());//-1---读完了，没有了*/
    15.  //循环读取
    16.  int c=-1;//没有内容可读
    17.  while ((c= fis.read())!=-1){

    // System.out.println(c+” “);

    1.      System.out.println((char)c+" ");
    2.  }
    4.  fis.close();

    } } ``` 一次读取一个字节数组

  • int read(byte[] b)：读取一个字节数组
    1.                 返回值是本次读取到的字节的个数
    1.                 参数用于每次存储字节数据的数组
    1.                 读取到文件末尾返回-1
    ```java package com.igeek_02;

import java.io.FileInputStream; import java.io.IOException; import java.util.Arrays;

/**

  • @author Lynn

  • @create 2020-12-11-10:42 */ public class InputStreamDemo2 { public static void main(String[] args) throws IOException {

    1.  FileInputStream fis=new FileInputStream("test.txt");
    2.  /*//封装一个数组--byte
    3.  byte[] b=new byte[3];
    4.  int len= fis.read(b);
    5.  System.out.println(len);//确定一次性读取的数组的长度是3
    6.  System.out.println(Arrays.toString(b));//[97,98,99]--数组的内容*/
    8.  //循环读取
    9.  byte[] bytes=new byte[3];
    10.  int len=-1;//说明没有内容了
    11.  while ((len= fis.read(bytes))!=-1){
    12.      String s=new String(bytes,0,len);
    13.      System.out.println(s);
    14.  }
    16.  fis.read();

    } } ```

    高效流

    Java在常规IO流的基础上，提供了更为高效的缓冲流，如下：
    高效字节缓冲流：BufferedInputStream/BufferedOutputStream
    高效流使用普通流对象作为构造方法参数。将普通流包装，提供高效的装饰。
    高效流write写出数据时，写出位置为缓冲区，并非目标资源。需要通过flush刷新方法将缓冲区的内容写出到目标文件中。
    高效输出流的关闭方法会自动调用flush方法。 ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-12-11-11:06 */

import java.io.BufferedOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;

/**

  • 高效流—高级流
  • 原理：缓存区临时存放多个数据，一次性调用底层的资源，减少调用的次数，从而提升程序运行的效率
  • 所以在高级流的底层需要一个低级流作为支撑 *
  • 高效字节流的api：
  • BufferedInputStream/BufferedOutputStream *
  • 高效流和普通流基本（完全）一样
  • 高效流使用普通流作为构造函数的参数，在普通流的基础上增加缓存区 *
  • 高效write写出的时候，写出的位置是在缓存区，并不是目标资源
  • 需要通过flush()方法将缓存区中的内容写出到目标资源中—目的是提高效率 *
  • 方法：
  • void flush()—刷新缓存区

  • void close()—关闭流，关闭前调用flush方法 */ public class BufferedStreamDemo { public static void main(String[] args) throws IOException {

    1.  //以高效字节输出流为例
    2.  //1.创建普通字节流
    3.  FileOutputStream fos=new FileOutputStream("test.txt");
    4.  //2.通过高效流使用普通流---将普通流作为参数参入高效流的构造函数
    5.  BufferedOutputStream bos=new BufferedOutputStream(fos);
    7.  //利用高效流处理数据
    8.  bos.write(97);
    9.  bos.write(new byte[]{100,101,102});
    11.  //刷新缓存区
    12.  bos.flush();
    14.  //关闭流--直接关闭高效流即可，普通流会随之关闭
    15.  bos.close();

    } } ```

    高效流使用案例1

    ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-12-11-11:17 */

import java.io.*;

/**

  • 高效流使用案例 */ public class BufferedWriterReaderDemo { public static void main(String[] args) throws IOException {

    1.  //1.创建普通流
    2.  FileWriter fw=new FileWriter("test2.txt");
    3.  //2.创建高效流--将普通流作为参数传入--对应FileWriter
    4.  BufferedWriter bw=new BufferedWriter(fw);
    6.  //写入数据
    7.  bw.write("天空飘来五个字");//支持字符，因为是BufferedWriter中的
    8.  //刷新缓存区
    9.  bw.flush();
    10.  //关闭流
    11.  bw.close();
    13.  System.out.println("---------------------------------------");
    15.  //1.创建普通流--保证文件存在
    16.  FileReader fr=new FileReader("test2.txt");
    17.  //2.创建高效流--将普通流作为参数传入--对应FileWriter
    18.  BufferedReader br=new BufferedReader(fr);
    20.  //读出数据
    21.  char[] chs=new char[1024];
    22.  //获取读取字符的个数
    23.  int len=br.read(chs);
    24.  //将字符转换成字符串
    25.  String s=new String(chs,0,len);
    26.  System.out.println(s);
    27.  //关闭流
    28.  br.close();

    } } ```

    高效流使用案例2

    特殊方法（属于高效流的）

  • public void readLine()—读取一行，读到末尾的时候返回null ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-12-11-11:17 */

import java.io.*;

/**

  • 高效流使用案例 *
  • 特殊方法（属于高效流的）

  • public void readLine()—读取一行，读到末尾的时候返回null */ public class BufferedWriterReaderDemo { public static void main(String[] args) throws IOException {

    1.  //1.创建普通流
    2.  FileReader fr=new FileReader("test3.txt");
    3.  //2.创建高效流--将普通流作为参数传入--对应FileWriter
    4.  BufferedReader br=new BufferedReader(fr);
    6.  //读取操作--每次读取一行
    7. /* System.out.println(br.readLine());
    8.  System.out.println(br.readLine());
    9.  System.out.println(br.readLine());
    10.  System.out.println(br.readLine());//null */
    12.  //循环读取
    13.  String s=null;//必须写成null，不能用 s=""
    14.  while ((s=br.readLine())!=null){
    15.      //输出的是一行
    16.      System.out.println(s);
    17.  }
    19.  //关闭流
    20.  br.close();
    22.  System.out.println("---------------------------------------");
  1. }

}

  1. <a name="aNVH7"></a>
  2. ### 演示流传输中编码的问题
  3. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/2706946/1607911005050-276a360d-0701-497d-b207-0add1a239eca.png#align=left&display=inline&height=194&margin=%5Bobject%20Object%5D&name=image.png&originHeight=324&originWidth=1246&size=420784&status=done&style=none&width=746)
  4. ```java
  5. package com.igeek_02;
  8. import java.io.*;
  10. /**
  11.  * @author Lynn
  12.  * @create 2020-12-14-9:57
  13.  */
  14. public class CharacterDemo {
  15.     public static void main(String[] args) throws IOException {
  16.         //使用utf-8格式输出到文件中，文件使用gbk观看乱码，使用utf-8就正常
  17.         FileOutputStream fos=new FileOutputStream("test5.txt");
  18.         OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
  19.         //写入数据
  20.         osw.write("你好");
  21.         osw.close();
  23.         //读出
  24.         FileInputStream fis=new FileInputStream("test5.txt");
  25.         InputStreamReader isr=new InputStreamReader(fis,"utf-8");
  26.         System.out.println((char)isr.read());
  27.         System.out.println((char)isr.read());
  28.         isr.close();
  30.     }
  32. }

高效流练习

  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-14-9:30
  6.  */
  8. import java.io.*;
  9. import java.util.ArrayList;
  10. import java.util.Collections;
  12. /**
  13.  * 练习
  14.  *
  15.  * 需求：
  16.  * 将test4.txt中的所有的名称进行读取，并且倒序再次输入到test.txt中
  17.  *
  18.  * 步骤：
  19.  * 1.定义一个集合存储名字
  20.  * 2.使用高效流一次读取一行
  21.  * 3.将读取的名字放到集合中
  22.  * 4.使用工具类中的反排序方法--reverse
  23.  * 5.使用高级流依次写出一个名字
  24.  */
  25. public class Test {
  26.     public static void main(String[] args) throws IOException {
  27.         //流 处理
  28.         FileReader fr=new FileReader("test4.txt");
  29.         BufferedReader br=new BufferedReader(fr);
  31.         //定义一个集合
  32.         ArrayList<String> list=new ArrayList<>();
  34.         //一次读取一个名字
  35.         String s=null;
  36.         while ((s=br.readLine())!=null){
  37.             //查看文档中的数据
  38.             System.out.println(s);
  39.             //保存到集合
  40.             list.add(s);
  41.         }
  42.         //关闭流
  43.         br.close();
  45.         //使用工具类中的反排序方法--reverse
  46.         Collections.reverse(list);
  48.         //使用高级流写出
  49.         FileWriter fw=new FileWriter("test4.txt");
  50.         BufferedWriter bw=new BufferedWriter(fw);
  51.         //写出操作
  52.         for (String name:list){
  53.             //将每一个名字放到test4.txt
  54.             bw.write(name);
  55.             //换行--相当于加一个回车
  56.             bw.newLine();
  57.         }
  59.         //关闭流
  60.         bw.close();
  61.     }
  62. }

文件复制

文件复制不使用字节数组

利用字节流将当前工程下的ASCII码表完整版.doc复制到当前工程下的ASCII码表完整版(副本).doc

案例代码六:

A：分析:
最终两个文件中的数据一致
1. 利用字节输入流关联ASCII码表完整版.doc文件
2. 利用字节输出流关联ASCII码表完整版(副本).doc文件
3. 循环从ASCII码表完整版.doc读一个字节,然后将这个字节写入到ASCII码表完整版(副本).doc,直到读到ASCII码表完整版.doc的末尾

  1. package com.igeek_01;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. /**  
  8. * @ClassName: CopyFileDemo  
  9. * @Description: 文件复制不使用字节数组
  10. * @date 2017年11月23日 上午8:58:46    
  11. * Company www.igeekhome.com
  12. *
  13. *    分析：
  14. *        1.    利用字节输入流关联ASCII码表完整版.doc文件
  15. *        2.    利用字节输出流关联ASCII码表完整版(副本).doc文件
  16. *        3.    循环从ASCII码表完整版.doc读一个字节,
  17. *            然后将这个字节写入到ASCII码表完整版(副本).doc,
  18. *            直到读到ASCII码表完整版.doc的末尾
  19. *        即先读后写
  20. */
  21. public class CopyFileDemo {
  22.     public static void main(String[] args) throws IOException {
  23.         //使用一次一个字节的方式完成复制
  24.         //创建IO流对象绑定IO资源
  25.         FileInputStream fis = new FileInputStream("ASCII码表完整版.doc");
  26.         FileOutputStream fos = new FileOutputStream("ASCII码表完整版(副本).doc");
  28.         //读取数据,读一个字节,写一个字节
  29.         //先读
  30.         //定义变量c,用于存储每次读取到的字节
  31.         int c=-1;
  32.         while((c=fis.read())!=-1) {
  33.             //后写
  34.             fos.write(c);
  35.         }
  37.         //关闭流
  38.         fos.close();
  39.         fis.close();
  41.     }
  42. }

文件复制使用字节数组

利用字节流和字节数组将当前工程下的ASCII码表完整版.doc复制到当前工程下的ASCII码表完整版(副本).doc

案例代码七:

A：分析:
最终两个文件中的数据一致
1. 定义一个长度为1024整数倍的字节数组
2. 利用字节输入流关联ASCII码表完整版.doc文件
3. 利用字节输出流关联ASCII码表完整版(副本).doc文件
4. 循环从ASCII码表完整版.doc读一个字节数组,然后将这个字节数组中有效的内容写入到ASCII码表完整版(副本).doc,直到读到ASCII码表完整版.doc的末尾

  1. package com.igeek_02;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. /**  
  8. * @ClassName: CopyFileDemo  
  9. * @Description: 文件复制使用字节数组
  10. * @date 2017年11月23日 上午9:05:23    
  11. * Company www.igeekhome.com
  12. *    
  13. *    分析：
  14. *        1.    定义一个长度为1024整数倍的字节数组
  15. *        2.    利用字节输入流关联ASCII码表完整版.doc文件
  16. *        3.    利用字节输出流关联ASCII码表完整版(副本).doc文件
  17. *        4.    循环从ASCII码表完整版.doc读一个字节数组,
  18. *            然后将这个字节数组中有效的内容写入到ASCII码表完整版(副本).doc,
  19. *            直到读到ASCII码表完整版.doc的末尾
  20. *        即先读后写
  21. */
  22. public class CopyFileDemo {
  23.     public static void main(String[] args) throws IOException {
  24.         //使用一次一个字节数组的方式完成复制
  25.         //创建IO流对象绑定IO资源
  26.         FileInputStream fis = new FileInputStream("ASCII码表完整版.doc");
  27.         FileOutputStream fos = new FileOutputStream("ASCII码表完整版(副本).doc");
  28.         //读取数据,读一个字节数组,写一个字节数组
  30.         //定义字节数组,用于存储每次读取到的数据
  31.         byte[] bytes = new byte[1024];
  32.         //定义变量,用于记录每次读取到数据的长度
  33.         int len=-1;
  34.         //先读
  35.         while((len = fis.read(bytes))!=-1) {
  36.             //后写
  37.             fos.write(bytes,0,len);
  38.         }
  40.         //关闭流
  41.         fos.close();
  42.         fis.close();
  44.     }
  45. }

转换流

Reader:
InputStreamReader可以完成字节输入流转换为字符输入流
Writer:
OutputStreamWriter可以完成字节输出流转换为字符输出流

  1. package com.igeek_01;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.io.OutputStreamWriter;
  7. /**  
  8. * @ClassName: OutputStreamWriterDemo  
  9. * @Description: OutputStreamWriter的使用
  10. * @date 2017年11月23日 上午10:47:22    
  11. * Company www.igeekhome.com
  12. *    
  13. *      需求:
  14. *          已经具备字节流,绑定了IO资源
  15. *          需要将字节流转成字符流
  16. *  
  17. *      此时,可以使用转换流,接收一个字节流对象,进行字符流的操作.
  18. *      转换流本身就是字符流
  19. *  
  20. *      转换流:
  21. *          Reader:
  22. *              InputStreamReader可以完成字节输入流转换为字符输入流
  23. *          Writer:
  24. *              OutputStreamWriter可以完成字节输出流转换为字符输出流。
  25. *  
  26. *      则转换流的使用方法:
  27. *          构造方法传入字节流对象
  28. *          自身调用字符流的方法
  29. */
  30. public class OutputStreamWriterDemo {
  31.     public static void main(String[] args) throws IOException {
  32.         //创建字节输出流
  33.         FileOutputStream fos = new FileOutputStream("test.txt");
  34.         //将字节流转为字符流,即通过字节流对象创建转换流对象
  35.         OutputStreamWriter osw = new OutputStreamWriter(fos);
  36.         //使用字符流的方法
  37.         osw.write("hello:中国");
  38.         //与高效流类似,转换流包含字节流,所以直接关闭转换流,字节流也关闭了
  39.         osw.close();
  41.     }
  42. }
  1. package com.igeek_01;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  7. /**  
  8. * @ClassName: InputStreamReaderDemo  
  9. * @Description: InputStreamReaderDemo的使用
  10. * @date 2017年11月23日 上午10:55:03    
  11. * Company www.igeekhome.com
  12. *    
  13. *      需求:
  14. *          已经具备字节流,绑定了IO资源
  15. *          需要将字节流转成字符流
  16. *  
  17. *      此时,可以使用转换流,接收一个字节流对象,进行字符流的操作.
  18. *      转换流本身就是字符流
  19. *  
  20. *      转换流:
  21. *          Reader:
  22. *              InputStreamReader可以完成字节输入流转换为字符输入流
  23. *          Writer:
  24. *              OutputStreamWriter可以完成字节输出流转换为字符输出流。
  25. *  
  26. *      则转换流的使用方法:
  27. *          构造方法传入字节流对象
  28. *          自身调用字符流的方法
  29. */
  30. public class InputStreamReaderDemo {
  31.     public static void main(String[] args) throws IOException {
  32.         //对比字节流操作字符与字符流操作字符的区别
  33.         //普通字节流
  34.         FileInputStream fis = new FileInputStream("test.txt");
  36.         int b=-1;
  37.         while((b=fis.read())!=-1) {
  38.             System.out.println((char)b);
  39.         }
  41.         fis.close();
  42.         System.out.println("=====================");
  44.         //字符流(这里使用转换流转成一个字符流)
  45.         FileInputStream fis2 = new FileInputStream("test.txt");
  46.         InputStreamReader isr = new InputStreamReader(fis2);
  48.         int c=-1;
  49.         while((c=isr.read())!=-1) {
  50.             System.out.println((char)c);
  51.         }
  53.         isr.close();
  55.     }
  56. }

序列化和反序列化

用于向流中写入对象的操作流 ObjectOutputStream称为序列化流
用于从流中读取对象的操作流 ObjectInputStream称为反序列化流
特点：用于操作对象。可以将对象写入到文件中，也可以从文件中读取对象。
ObjectOutputStream序列化流
public final void writeObject(Object obj)
ObjectInputStream反序列化流
public final Object readObject()
每个被序列化操作的类型必须实现Serializable接口(具备序列化功能的标记接口),让其具备序列化能力。

  1. package com.igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-14-10:18
  6.  */
  9. import java.io.Serializable;
  11. /**
  12.  * 序列化和反序列化：
  13.  * 序列化：利用序列化流将一个对象的整体转换为二进制的数据，并且存储到文件中
  14.  * 将对象永久性的存入一个文件，叫做序列化，读取的过程叫做反序列化
  15.  *
  16.  * 对象是需要封装的，为了实现对象的序列化，我们要将对象实现一个序列化接口--Serializable
  17.  * 这个接口中没有方法，就是一个规范，只要实现了这个接口，那么序列化的时候就不会出现问题
  18.  *
  19.  * 序列化版本号：序列化ID（serialVersionUID），用于记录对象的类型
  20.  * 每一个被序列化的操作对象操作其对象上午ID与接收类型的ID必须一致
  21.  * 序列化的ID和反序列化的ID必须一致
  22.  *
  23.  * 封装一个开发级别的实体类（标准的）
  24.  * 1.必须实现序列化接口--声明UID
  25.  * 2.属性私有化，并且声明get/set方法
  26.  * 3.声明无参有参构造函数
  27.  * 4.重写HashCode和equals方法
  28.  * 5.重写toString方法
  29.  *
  30.  * 拓展：
  31.  * transient关键字在序列化中的使用：是一个修饰符，被修饰的属性可以在序列化中被忽略，
  32.  * 在某些特定的业务场景会使用
  33.  */
  34. class Person_up implements Serializable {
  35.     private static final long serialVersionUID = 324576945194316948L;
  36.     /**
  37.      * serialVersionUID:生成的标准的唯一的码
  38.      */
  39. //    private static final long serialVersionUID=;
  41.     //定义普通的标识码--普通版本码
  42. //    private static final long serialVersionUID=1L;
  43.     private String name;
  45.     //这个age就不会被序列化
  46.     private transient int age;
  48.     public Person_up() {
  49.     }
  51.     public Person_up(String name, int age) {
  52.         this.name = name;
  53.         this.age = age;
  54.     }
  56.     public String getName() {
  57.         return name;
  58.     }
  60.     public void setName(String name) {
  61.         this.name = name;
  62.     }
  64.     public int getAge() {
  65.         return age;
  66.     }
  68.     public void setAge(int age) {
  69.         this.age = age;
  70.     }
  72.     @Override
  73.     public String toString() {
  74.         return "Person{" +
  75.                 "name='" + name + '\'' +
  76.                 ", age=" + age +
  77.                 '}';
  78.     }
  80.     @Override
  81.     public boolean equals(Object o) {
  82.         if (this == o) return true;
  83.         if (o == null || getClass() != o.getClass()) return false;
  85.         Person_up person = (Person_up) o;
  87.         if (age != person.age) return false;
  88.         return name != null ? name.equals(person.name) : person.name == null;
  89.     }
  91.     @Override
  92.     public int hashCode() {
  93.         int result = name != null ? name.hashCode() : 0;
  94.         result = 31 * result + age;
  95.         return result;
  96.     }
  97. }
  1. package com.igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-14-10:35
  6.  */
  8. import java.io.FileOutputStream;
  9. import java.io.IOException;
  10. import java.io.ObjectOutput;
  11. import java.io.ObjectOutputStream;
  13. /**
  14.  * 序列化对象
  15.  *
  16.  * 序列化流：
  17.  * ObjectOutputStream：序列化流（对象输出流）
  18.  * public final void writeObject(Object obj)
  19.  *
  20.  * ObjectInputStream：反序列化流（对象输入流）
  21.  * public final Object readObject()
  22.  */
  23. public class SerializableDemo {
  24.     public static void main(String[] args) throws IOException {
  25.         //准备被序列化的对象
  26.         Person_up p=new Person_up("jack",18);
  28.         //进行序列化操作
  29.         FileOutputStream fos=new FileOutputStream("person_up.txt");
  30.         ObjectOutput oos=new ObjectOutputStream(fos);
  32.         //开始序列化
  33.         oos.writeObject(p);
  35.         //关闭流
  36.         oos.close();
  37.     }
  38. }
  1. package com.igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-14-10:35
  6.  */
  8. import java.io.*;
  10. /**
  11.  * 序列化对象
  12.  *
  13.  * 序列化流：
  14.  * ObjectOutputStream：序列化流（对象输出流）
  15.  * public final void writeObject(Object obj)
  16.  *
  17.  * ObjectInputStream：反序列化流（对象输入流）
  18.  * public final Object readObject()
  19.  */
  20. public class SerializableDemo2 {
  21.     public static void main(String[] args) throws IOException,Exception {
  23.         //进行反序列化操作--保证对象存在
  24.         FileInputStream fis=new FileInputStream("person_up.txt");
  25.         ObjectInputStream ois=new ObjectInputStream(fis);
  27.         //开始反序列化
  28.        Person_up p=(Person_up) ois.readObject();
  29.         System.out.println(p.getName());
  30.         System.out.println(p.getAge());
  31.         System.out.println(p);
  33.         //关闭流
  34.         ois.close();
  35.     }
  36. }

打印流

  1. package com.igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-14-11:12
  6.  */
  8. import java.io.FileNotFoundException;
  9. import java.io.PrintWriter;
  11. /**
  12.  * 演示操作：
  13.  *
  14.  * 打印流（自动行刷新流）：只有输出没有输入
  15.  * printStream：字节打印流，调用println方法自动刷新
  16.  * printwriter：字符打印流，指定自动化刷新开关后，调用println方法自动刷新，无需手动调用flush方法
  17.  * 每执行一次会自动刷新缓存区
  18.  * 在网络传输中使用很多
  19.  */
  20. public class PrintwriterDemo {
  21.     public static void main(String[] args) throws FileNotFoundException {
  22.         //创建对象
  23.         PrintWriter pw=new PrintWriter("test8.txt");
  24.         //println自带换行
  25.         pw.println("干饭啦");
  26.         pw.println("干饭啦");
  27.         pw.println("干饭啦");
  28.         pw.println("干饭啦");
  29.         pw.println("干饭啦");
  31.         pw.print("我是谁");
  32.         pw.print("\n");//制表符在这个打印方法中是有效的
  33.         pw.print("我是哪");
  34. //        pw.print("\\n");无效
  35.         pw.print("我在干什么");
  36.         pw.close();
  37.     }
  38. }