Java流处理之序列化和打印流

àì夳堔傛蜴生んèń 2024-02-17 13:15 30阅读 0赞

#### 文章目录 ####

*  序列化
 *   *  概述
     *  ObjectOutputStream类
     *   *  构造方法
         *  序列化操作
     *  ObjectInputStream类
     *   *  构造方法
         *  反序列化操作1
         *  \*\*反序列化操作2\*\*
     *  案例：序列化集合
     *   *  案例分析
         *  案例实现
 *  打印流
 *   *  概述
     *  PrintStream类
     *   *  构造方法
         *  改变打印流向

## 序列化 ##

### 概述 ###

Java 提供了一种对象**序列化**的机制。用一个字节序列可以表示一个对象，该字节序列包含该`对象的数据`、`对象的类型`和`对象中存储的属性`等信息。字节序列写出到文件之后，相当于文件中**持久保存**了一个对象的信息。  
反之，该字节序列还可以从文件中读取回来，重构对象，对它进行**反序列化**。`对象的数据`、`对象的类型`和`对象中存储的数据`信息，都可以用来在内存中创建对象。看图理解序列化：  
![序列化与反序列化][08bf65a94f5b40c09bb6aff67cfd1c92.png]

### ObjectOutputStream类 ###

`java.io.ObjectOutputStream` 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

#### 构造方法 ####

*  `public ObjectOutputStream(OutputStream out)`： 创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("employee.txt");
    ObjectOutputStream out = new ObjectOutputStream(fileOut);

#### 序列化操作 ####

1.  一个对象要想序列化，必须满足两个条件:

*  该类必须实现`java.io.Serializable` 接口，`Serializable` 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出`NotSerializableException` 。
 *  该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用`transient` 关键字修饰。

public class Employee implements java.io.Serializable {
        
        public String name;
        public String address;
        public transient int age; // transient瞬态修饰成员,不会被序列化
        public void addressCheck() {
        
          	System.out.println("Address  check : " + name + " -- " + address);
        }
    }

2.写出对象方法

*  `public final void writeObject (Object obj)` : 将指定的对象写出。

public class SerializeDemo{
        
       	public static void main(String [] args)   {
        
        	Employee e = new Employee();
        	e.name = "zhangsan";
        	e.address = "北京东城区";
        	e.age = 20; 
        	try {
        
          		// 创建序列化流对象
              ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
            	// 写出对象
            	out.writeObject(e);
            	// 释放资源
            	out.close();
            	fileOut.close();
            	System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
            } catch(IOException i)   {
        
                i.printStackTrace();
            }
       	}
    }
    输出结果：
    Serialized data is saved

### ObjectInputStream类 ###

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

#### 构造方法 ####

*  `public ObjectInputStream(InputStream in)`： 创建一个指定InputStream的ObjectInputStream。

#### 反序列化操作1 ####

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用`ObjectInputStream`读取对象的方法：

*  `public final Object readObject ()` : 读取一个对象。

public class DeserializeDemo {
        
       public static void main(String [] args)   {
        
            Employee e = null;
            try {
        		
                 // 创建反序列化流
                 FileInputStream fileIn = new FileInputStream("employee.txt");
                 ObjectInputStream in = new ObjectInputStream(fileIn);
                 // 读取一个对象
                 e = (Employee) in.readObject();
                 // 释放资源
                 in.close();
                 fileIn.close();
            }catch(IOException i) {
        
                 // 捕获其他异常
                 i.printStackTrace();
                 return;
            }catch(ClassNotFoundException c)  {
        
            	// 捕获类找不到异常
                 System.out.println("Employee class not found");
                 c.printStackTrace();
                 return;
            }
            // 无异常,直接打印输出
            System.out.println("Name: " + e.name);	// zhangsan
            System.out.println("Address: " + e.address); // beiqinglu
            System.out.println("age: " + e.age); // 0
        }
    }

**对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 `**ClassNotFoundException**` 异常。**

#### **反序列化操作2** ####

**另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个**`InvalidClassException`异常。发生这个异常的原因如下：

*  该类的序列版本号与从流中读取的类描述符的版本号不匹配
 *  该类包含未知数据类型
 *  该类没有可访问的无参数构造方法

`Serializable` 接口给需要序列化的类，提供了一个序列版本号。`serialVersionUID` 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

public class Employee implements java.io.Serializable {
        
         // 加入序列版本号
         private static final long serialVersionUID = 1L;
         public String name;
         public String address;
         // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
         public int eid; 
    
         public void addressCheck() {
        
             System.out.println("Address  check : " + name + " -- " + address);
         }
    }

### 案例：序列化集合 ###

1.  将存有多个自定义对象的集合序列化操作，保存到`list.txt`文件中。
2.  反序列化`list.txt` ，并遍历集合，打印对象信息。

#### 案例分析 ####

1.  把若干学生对象 ，保存到集合中。
2.  把集合序列化。
3.  反序列化读取时，只需要读取一次，转换为集合类型。
4.  遍历集合，可以打印所有的学生信息

#### 案例实现 ####

public class SerTest {
        
    	public static void main(String[] args) throws Exception {
        
    		// 创建 学生对象
    		Student student = new Student("老王", "laow");
    		Student student2 = new Student("老张", "laoz");
    		Student student3 = new Student("老李", "laol");
    
    		ArrayList<Student> arrayList = new ArrayList<>();
    		arrayList.add(student);
    		arrayList.add(student2);
    		arrayList.add(student3);
    		// 序列化操作
    		// serializ(arrayList);
    		
    		// 反序列化  
    		ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("list.txt"));
    		// 读取对象,强转为ArrayList类型
    		ArrayList<Student> list  = (ArrayList<Student>)ois.readObject();
    		
          	for (int i = 0; i < list.size(); i++ ){
        
              	Student s = list.get(i);
            	System.out.println(s.getName()+"--"+ s.getPwd());
          	}
    	}
    
    	private static void serializ(ArrayList<Student> arrayList) throws Exception {
        
    		// 创建 序列化流 
    		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
    		// 写出对象
    		oos.writeObject(arrayList);
    		// 释放资源
    		oos.close();
    	}
    }

## 打印流 ##

### 概述 ###

平时我们在控制台打印输出，是调用`print`方法和`println`方法完成的，这两个方法都来自于`java.io.PrintStream`类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

### PrintStream类 ###

#### 构造方法 ####

*  `public PrintStream(String fileName)`： 使用指定的文件名创建一个新的打印流。

构造举例，代码如下：

PrintStream ps = new PrintStream("ps.txt")；

#### 改变打印流向 ####

`System.out`就是`PrintStream`类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个"小把戏"，改变它的流向。

public class PrintDemo {
        
        public static void main(String[] args) throws IOException {
        
    		// 调用系统的打印流,控制台直接输出97
            System.out.println(97);
          
    		// 创建打印流,指定文件的名称
            PrintStream ps = new PrintStream("ps.txt");
          	
          	// 设置系统的打印流流向,输出到ps.txt
            System.setOut(ps);
          	// 调用系统的打印流,ps.txt中输出97
            System.out.println(97);
        }
    }

相关文章：  
[Java流处理之高效读写的缓冲流][Java]  
[Java流处理之转换编码的转换流][Java 1]  
[File类详解(获取文件名称、大小、路径、创建等)][File]

[08bf65a94f5b40c09bb6aff67cfd1c92.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/7db9488f14244bf282855b506fdf30f1.png
[Java]: https://blog.csdn.net/qq_35427589/article/details/124471372
[Java 1]: https://blog.csdn.net/qq_35427589/article/details/124488362
[File]: https://blog.csdn.net/qq_35427589/article/details/124442107