Java Serializable（序列化）实例 第二部分

第一，实现serialize接口：

package TestXL;

import java.io.*;

public class  BoxSerialize implements Serializable  
{  
    private int width;  
    private int height;  
    private transient int longth; //他将不被序列化
    private static int ss;

    public void setWidth(int width){  
        this.width  = width;  
    }  
    public void setHeight(int height){  
        this.height = height;  
    }  
    public void setlongth(int longth){  
        this.longth = longth;  
    } 

    public void setss(int ss){  
        ss = ss;  //this.ss = ss; 这两句是有去别的。
    } 

    public static void main(String[] args){  
        BoxSerialize myBox = new BoxSerialize();  
        myBox.setWidth(50);  
        myBox.setHeight(30); 
        myBox.setlongth(40);
        myBox.setss(100);

        try{  
            FileOutputStream fs = new FileOutputStream("G:\\uploads\\boxtest.txt");  
            ObjectOutputStream os =  new ObjectOutputStream(fs);  
            os.writeObject(myBox);  
            os.close();  
        }catch(Exception ex){  
            ex.printStackTrace();  
        }  

        try{
            FileInputStream fs = new FileInputStream("G:\\uploads\\boxtest.txt");
            ObjectInputStream in =  new ObjectInputStream(fs);
            BoxSerialize bs = (BoxSerialize) in.readObject();
            System.out.println(bs.height+","+bs.width+bs.longth+".."+bs.ss + ".."+BoxSerialize.ss);
            in.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }  

}  

第二，实现Externalizable接口：

1.部分：

package TestXL;

import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
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接口实现序列化，其中的transient修饰的变量对transient关键字不再起作用。
 */
public class ExternalizableTest implements Externalizable{

    private transient String content = "是的，我将会被序列化，不管我是否被transient关键字修饰";

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // TODO Auto-generated method stub
        out.writeObject(content);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // TODO Auto-generated method stub
        content = (String)in.readObject();
    }

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        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();
    }
}

2.部分：

package TestXL;

import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.Date;

/*
 * 测试类
 */
public class Test{

    //序列化对象到文件
    public static void serialize(String filename) throws FileNotFoundException, IOException{
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File(filename)));
        UserInfo user = new UserInfo("lindaiyu","xxchen",20);
        out.writeObject(user);
        out.close();
    }

    //从文件反序列化到对象
    public static void deserialize(String filename) throws FileNotFoundException, IOException, ClassNotFoundException{
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File(filename)));
        UserInfo user = (UserInfo) in.readObject();
        System.out.println(user.toString());
        in.close();
    }

    public static void main(String[] args) {
        try {
            serialize("G:\\uploads\\test.txt");
            System.out.println("序列化完成。");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        try {
            deserialize("G:\\uploads\\test.txt");
            System.out.println("反序列化完成。");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

/*
 * 序列化的类
 */
class UserInfo implements Externalizable {

    public String userName;
    public String userPassword;
    public int userAge;

    /*
     * 构造函数
     */
    public UserInfo() {
        // TODO Auto-generated constructor stub
    }

    public UserInfo(String name,String password,int age){
        this.userName= name;
        this.userPassword = password;
        this.userAge = age;
    }

    //当序列化对象时,该方法自动调用  
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // TODO Auto-generated method stub
        System.out.println("现在执行序列化方法。");
        //可以在序列化是写非自身的变量
        Date d = new Date();
        out.writeObject(d);

        /*
         * 第一.可以将信息进行加密，以保证安全性。
         * 第二.这人只将变量userName，userPassword进行序列化
         */
        out.writeObject(this.userName);
        out.writeObject(this.userPassword);
    }

    //当反序列化对象时,该方法自动调用  
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // TODO Auto-generated method stub
        System.out.println("现在执行反序列化方法。");
        Date d = (Date)in.readObject();
        System.out.println(d);
        this.userName = (String) in.readObject();
        this.userPassword = (String) in.readObject();
    }

    public String toString(){
        return "用户名: "+this.userName+";密码："+this.userPassword+   
                ";年龄："+this.userAge;   
    }
}

第三：下面是一些总结，没有实例。
1、序列化ID

序列化 ID 在 Eclipse 下提供了两种生成策略，一个是固定的 1L，一个是随机生成一个不重复的 long 类型数据（实际上是使用 JDK 工具生成），在这里有一个建议，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。这也可能是造成序列化和反序列化失败的原因，因为不同的序列化id之间不能进行序列化和反序列化。

2.序列化前和序列化后的对象的关系

是 “==”还是equal？ or 是浅复制还是深复制？
答案：深复制，反序列化还原后的对象地址与原来的的地址不同
序列化前后对象的地址不同了，但是内容是一样的，而且对象中包含的引用也相同。换句话说，通过序列化操作,我们可以实现对任何可Serializable对象的”深度复制（deep copy）”——这意味着我们复制的是整个对象网，而不仅仅是基本对象及其引用。对于同一流的对象，他们的地址是相同，说明他们是同一个对象，但是与其他流的对象地址却不相同。也就说，只要将对象序列化到单一流中，就可以恢复出与我们写出时一样的对象网，而且只要在同一流中，对象都是同一个。