239-Java文件与流-文件与流-ObjectInputStream与ObjectOutputStream对象序列化.md

注意

本博文仅供学术研究和交流参考，严禁将其用于商业用途。如因违规使用产生的任何法律问题，使用者需自行负责。

概念

示例代码

package com.tencent.chapter03.io流.序列化;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectInputStreamAndObjectOutputStream {

	/**
		序列化：对象 -> 字节序列，将对象转换为字节序列，可以保存在本地文件，也可以在网络之间或进程之间传递对象
		
		反序列化： 字节序列 -> 对象，字节序列恢复为对象
		
		注意：
			1.需要实现序列的对象，必须实现序列化接口Serializable或者Externalizable
				public class Student implements Serializable{}
				public class StuClass implements Serializable{}
				
			2.如果父类已经实现序列化接口，子类可以不用在实现
				public class Person implements Serializable{}
				public class Student extends Person{}
				
			3.建议所有的类显示声明serialVersionUID，用于序列化与反序列化判断对象是否为同一类型
				private static final long serialVersionUID = -6873608134389523921L;
				
			4.transient 修饰属性不被序列化出去
				private transient String address;
	 */
	public static void main(String[] args) {
		/**
		 * new对象
		 */
		StuClass stuClass = new StuClass(125, "Java8班");
		Student jinquan = new Student(10000, "锦权", 18, "男", "东软大厦125C",stuClass);
		
		/**
		 * 序列化
		 */
		serialize(jinquan);
		
		/**
		 * 反序列化
		 */
		deSerialize();
		
	}
	/**
	 * 反序列化
	 */
	private static void deSerialize() {
		ObjectInputStream input = null;
		try {
			//对象输入流
			FileInputStream in = new FileInputStream("file/student.txt");
			input = new ObjectInputStream(in);
			
			//读取对象
			Student jinquanClone = (Student)input.readObject();
			System.out.println(jinquanClone.toString());
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			//关闭资源
			try {
				if(input != null)
				{
					input.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	/**
	 * 序列化：对象 -> 字节序列
	 * @param 待序列化的对象
	 */
	private static void serialize(Student stu) {
		ObjectOutputStream output = null;
		try {
			//对象输出流
			FileOutputStream out = new FileOutputStream("file/student.txt");
			output = new ObjectOutputStream(out);
			
			//将对象写入文件
			output.writeObject(stu);
			
			//刷新暂存区
			output.flush();
			
			System.out.println("序列化成功！！");
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//关闭资源
			try {
				if(output != null)
				{
					output.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
}

package com.tencent.chapter03.io流.序列化;

import java.io.Serializable;

public class Person implements Serializable{

}

package com.tencent.chapter03.io流.序列化;

import java.io.Serializable;

//学生班级
public class StuClass implements Serializable,Cloneable{

	//班级编号 125
	private int cid;
	
	//班级名称 "java8班"
	private String cname;

	//构造 函数
	public StuClass() {
		super();
	}
	public StuClass(int cid, String cname) {
		super();
		this.cid = cid;
		this.cname = cname;
	}
	
	//访问器
	public int getCid() {
		return cid;
	}
	public void setCid(int cid) {
		this.cid = cid;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}

	//重写父类的toString
	@Override
	public String toString() {
		return "StuClass [cid=" + cid + ", cname=" + cname + "]";
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

package com.tencent.chapter03.io流.序列化;

//学生类
public class Student extends Person implements Cloneable{

	private static final long serialVersionUID = -6873608134389523921L;
	
	//成员变量
	private int sid;
	private String sname;
	private int age;
	private String sex;
	private transient String address;//transient 保护属性不被序列化出去
	
	private StuClass stuClass;//复合属性
	
	//构造函数
	public Student()
	{
		
	}
	public Student(int sid, String sname, int age, String sex, String address, StuClass stuClass) {
		super();
		this.sid = sid;
		this.sname = sname;
		this.age = age;
		this.sex = sex;
		this.address = address;
		this.stuClass = stuClass;
	}


	//访问器
	public int getSid() {
		return sid;
	}
	public void setSid(int sid) {
		this.sid = sid;
	}
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public StuClass getStuClass() {
		return stuClass;
	}
	public void setStuClass(StuClass stuClass) {
		this.stuClass = stuClass;
	}
	
	//重写父类toString()
	@Override
	public String toString() {
		return "Student [sid=" + sid + ", sname=" + sname + ", age=" + age + ", sex=" + sex + ", address=" + address
				+ ", stuClass=" + stuClass + "]";
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Student stuClone = (Student)super.clone();
		
		StuClass stuClassClone = (StuClass)stuClone.getStuClass().clone();
		stuClone.setStuClass(stuClassClone);
		
		return stuClone;
	}
}

package com.tencent.chapter03.io流.序列化;

public class Test深拷贝_浅拷贝 {

	/**
	  		浅拷贝：克隆对象时，不会克隆引用对象的属性，例如，不会克隆Student的StudentClass
	  		
	  		深拷贝：克隆对象时，会克隆引用对象的属性，例如，会克隆Student的StudentClass
	  		
	  			1. 对象序列化默认做深拷贝
	  			
	  			2. 其他对象需要被拷贝
	  				① 实现允许克隆的接口
	  					public class Student implements Cloneable{}
	  					
	  				② 重写clone方法
	  					protected Object clone() throws CloneNotSupportedException {
							Student stuClone = (Student)super.clone();
							
							StuClass stuClassClone = (StuClass)stuClone.getStuClass().clone();
							stuClone.setStuClass(stuClassClone);
							
							return stuClone;
						}
	 */
	public static void main(String[] args) throws CloneNotSupportedException {
		
		/**
		 * 原对象
		 */
		StuClass stuClass = new StuClass(125, "Java8班");
		Student jinquan = new Student(10000, "锦权", 18, "男", "东软大厦125C",stuClass);
		
		/**
		 * 克隆对象
		 */
		Student jinquanClone = (Student)jinquan.clone();
		
		//输出两个对象Student的地址
		System.out.println(jinquan.hashCode());     //2059712038
		System.out.println(jinquanClone.hashCode());//143833026
		
		jinquanClone.setSex("女");
		
		System.out.println("原来的锦权：" + jinquan.getSex());     //男
		System.out.println("后来的锦权：" + jinquanClone.getSex());//女
		
		//输出两个对象StudentClass的地址
		System.out.println(jinquan.getStuClass().hashCode());     //143833026
		System.out.println(jinquanClone.getStuClass().hashCode());//143833026
		
		jinquanClone.getStuClass().setCname("Java8大神班");
		
		System.out.println("原来的锦权：" + jinquan.getStuClass().getCname());     //Java8大神班
		System.out.println("后来的锦权：" + jinquanClone.getStuClass().getCname());//Java8大神班
	}
}

---

分割线

---

相关信息

以上就是我关于 Java文件与流-文件与流-ObjectInputStream与ObjectOutputStream对象序列化 知识点的整理与总结的全部内容，希望对你有帮助。。。。。。。