1.序列化的对象
/**
* 需要序列化的对象 实体类 需要继承Serializable
*
* @author lm 说明：1.序列化不会保存静态变量，因为静态变量是对象的状态 2.Transient 不会被序列化 因为Transient 是临时变量
*
*/
public class Model implements Serializable {
private static final long serialVersionUID = 1L;
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
2.序列化 属于test类
/**
*
* @param m
* 要序列化的对象
* @return byte[] 序列化后的字节数组
*/
public byte[] tobyte(Model m) {
// 设置属性
m.setAge(10);
m.setName("小明");
// 输出流ByteArrayOutputStream是跟字节交互的
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 输出流 ObjectOutputStream 是跟对象交互的 可以吧对象转换成ByteArrayOutputStream输出流
ObjectOutputStream oos;
byte[] bytes = null;
try {
oos = new ObjectOutputStream(baos);
oos.writeObject(m);
bytes = baos.toByteArray();
oos.close();
System.out.println("序列化的数据 是字节数组：" + bytes);
} catch (Exception e) {
e.printStackTrace();
}
return bytes;
}
3.返序列化 属于test类
/**
*
* 把序列化的字节数组 返序列化成对象
*
* @param byte[] 序列化后的字节数组
*
* @return Model
*/
public Model frombyte(byte[] bytes) {
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois;
Model retModel = null;
try {
ois = new ObjectInputStream(bais);
bais.close();
retModel = (Model) ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return retModel;
}
4.测试
public static void main(String[] args) {
Model model = new Model();
model.setAge(18);
model.setName("那个她");
test test=new test();
byte [] rbytes=test.tobyte(model);
System.out.println("序列化后的字节数组："+rbytes);
Model m2= test.frombyte(rbytes);
System.out.println("反序列化后对象："+m2.getAge()+"--"+m2.getName());
}
