Externalizable和Serializable

Externalizable继承于Serializable
Externalizable序列化时会调用默认构造器
Serializable序列化时不会调用默认构造器

Externalizable可以通过writeObject指定序列化哪个属性默认是不序列化,被transient修饰的属性也将被序列化

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
 
//Externalizable接口的使用
public class ExternalizableTest implements Externalizable {
 
    private transient String content = "是的，我将会被序列化，不管我是否被transient关键字修饰";
 
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(content);
    }
 
    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        content = (String) in.readObject();
    }
 
    public static void main(String[] args) throws Exception {
        
        ExternalizableTest et = new ExternalizableTest();
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                new File("test")));
        out.writeObject(et);
 
        ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
                "test")));
        et = (ExternalizableTest) in.readObject();
        System.out.println(et.content);
 
        out.close();
        in.close();
    }
}
Serializable序列化除了static和transient修饰的属性，也可以全部加上transient通过writeObject指定序列化属性被指定的属性无视transient修饰

transient：

1，变量一但被transient修饰，变量将不再是对象序列化的一部分，该变量将不被序列化，反序列化后也无法访问

2，transient只能用于修饰变量，而不能修饰方法和类，本地变量无法被修饰，变量如果是用户自定义的则该类需要基础Serializable接口

3，静态变量被transient修饰和不被修饰都无法序列化

由于类中的属性加上static关键字后，程序运行结果依然不变，所以反序列化后带有static关键字的属性的值是从JVM中获取的

 

实现了Externalizable或Serializable接口的类

可以通过objectOutputStrem进行序列化：利用fileoutputstrem可以将对象持久化在本地，也可以输出到另一台机子上

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
// 使用transient关键字不序列化某个变量 注意读取的时候，读取数据的顺序一定要和存放数据的顺序保持一致
public class TransientTest {
    
    public static void main(String[] args) {
        
        User user = new User();
        user.setUsername("Alexia");
        user.setPasswd("123456");
        
        System.out.println("read before Serializable: ");
        System.out.println("username: " + user.getUsername());
        System.err.println("password: " + user.getPasswd());
        
        try {
            ObjectOutputStream os = new ObjectOutputStream(
                    new FileOutputStream("C:/user.txt"));
            os.writeObject(user); // 将User对象写进文件
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                    "C:/user.txt"));
            user = (User) is.readObject(); // 从流中读取User的数据
            is.close();
            
            System.out.println("\nread after Serializable: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
 
class User implements Serializable {
    private static final long serialVersionUID = 1L;  
    
    private String username;
    private transient String passwd;
    
    public String getUsername() {
        return username;
    }
    
    public void setUsername(String username) {
        this.username = username;
    }
    
    public String getPasswd() {
        return passwd;
    }
    
    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }
 
}

利用byteArrayOutputStrem可以将对象序列化到内存中，也可以输出到另外一台机子上

import java.io.*;
import java.util.*;

public class SerialCtl implements Serializable{
        String a;
        transient String b;
        public SerialCtl(String aa, String bb){
                a="Not Transient:"+aa;
                b="Transient:"+bb;
        }
        public String toString(){
                return a+"\n"+b;
        }

        private void writeObject(ObjectOutputStream o)throws IOException{
                o.defaultWriteObject();
        //      o.writeObject(b);
        }
        private void readObject(ObjectInputStream streamr)throws IOException, ClassNotFoundException{
                streamr.defaultReadObject();
        //      b=(String)streamr.readObject();
        }

        public static void main(String[] args){
                SerialCtl sc =
                        new SerialCtl("Test1","Test2");
                System.out.println("Before:\n"+sc);
                ByteArrayOutputStream buf =
                        new ByteArrayOutputStream();
                try{
                        ObjectOutputStream out1 = new
                                ObjectOutputStream(buf);

                        out1.writeObject(sc);

                        ObjectInputStream in1 = new
                                ObjectInputStream(new
                                        ByteArrayInputStream(buf.toByteArray()));

                        SerialCtl sc2 = (SerialCtl)in1.readObject();
                        System.out.println("After:\n"+sc2);

                }catch(ClassNotFoundException e){
                        e.printStackTrace();
                }catch(IOException e){
                        e.printStackTrace();

                }
        }
}

 

ps:用于学习记录,本人小白一个，如果有误，希望大佬多多指点，谢谢^_^