java输入输出（10）自定义序列化

1. 在序列化过程中，如果某些变量不想被序列化，可以使用transient关键字轻易地实现，以下为示例

   public class Person1 implements java.io.Serializable {
       
       private transient int num;
   //    num变量用transient关键字修饰，所以它不会被序列化，可以在读取的时候证明
       
       public Person1(int num){
           this.num = num;
       }
   
       public int getNum() {
           return num;
       }
   
       public void setNum(int num) {
           this.num = num;
       }
   }
   

   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.ObjectInputStream;
   import java.io.ObjectOutputStream;
   
   public class TransientTest {
       public static void main(String args[]){
           try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("transient.txt"));
               ObjectInputStream ois = new ObjectInputStream(new FileInputStream("transient.txt"))){
               Person1 person1 = new Person1(12);
               oos.writeObject(person1);
               Person1 person11 = (Person1)ois.readObject();
               System.out.println(person11.getNum());
   //            这一句会输出0，因为num没有被序列化
           }catch (Exception e){
               e.printStackTrace();
           }
       }
   }
   //运行程序可以看到程序输出了 0
   

    

2. 除此之外，还可以通过重写Serialable接口的一些方法来控制序列化，主要有三个，讲解穿插在代码之中

   import java.io.IOException;
   import java.io.ObjectStreamException;
   import java.util.ArrayList;
   
   public class Person2 implements java.io.Serializable{
       private String name;
       private int age;
       public Person2(String name, int age) {
           this.age = age;
           this.name = name;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public int getAge() {
           return age;
       }
   
       public void setAge(int age) {
           this.age = age;
       }
   
   //   writeObject可以规定序列化时的处理，这里是将name翻转，一般在writeObject处理后在readObject要有相应的反
   //    处理以便将数据回复过来
       private void writeObject(java.io.ObjectOutputStream out) throws IOException{
           out.writeObject(new StringBuffer(name).reverse());
       }
   
   
   //    readObject可以规定反序列化过程的处理
       private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{
           this.name = ((StringBuffer)in.readObject()).reverse().toString();
           this.age = in.readInt();
       }
   
   //    writeReplace可以重写规定反序列化的处理过程，一旦使用了这个方法，那么readObject的处理将被抛弃
       private Object writeReplace() throws ObjectStreamException{
           ArrayList<Object>list = new ArrayList<Object>();
           list.add(name);
           list.add(age);
           return  list;
       }
   
   }
   

   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.ObjectInputStream;
   import java.io.ObjectOutputStream;
   import java.util.ArrayList;
   
   public class ReplaceTest {
       public static void main(String args[]){
           try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("replace.txt"));
               ObjectInputStream ois = new ObjectInputStream(new FileInputStream("replace.txt"))){
               Person2 person2 = new Person2("孙悟空", 500);
               oos.writeObject(person2);
   
               ArrayList list = (ArrayList)ois.readObject();
               System.out.println(list);
   //          这一步执行的是Person2中writeReplace方法，所以是返回一个集合
           }catch (Exception e){
               e.printStackTrace();
           }
       }
   }
   //程序运行结果：
   //        [孙悟空, 500]

   这是我看李刚编著的《疯狂Java讲义》后总结出来的。