浅深克隆和序列化总结

于 2010-12-28 17:07:49 发布
阅读量173 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： io-nio 文章标签： JVM Socket thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/iteye_14190/article/details/81993955
[b]序列化的原则：[/b]并不是实现序列化的类中所有的属性都可以被自动的序列化。1.父类没有实现序列化，子类序列化时，继承父类的属性则不会被序列 化。2.static类型不能被序列化。 why？3.transient关键字修饰的属性和方法不能被序列化。因此有时候有些属性或方法不想被序列化时，可以用transient将其限制。那么 一般什么属性最好不要被序列化呢？1.线程的相关属性。2.要访问IO，本地资源，网络资源的属性。3.没有实现序列化的属性既没有实现序列化，又没有用 transient标识的，会抛出NotSerializableException。

[b]相关注意事项[/b] a）序列化时，只对对象的状态进行保存，而不管对象的方法；
b）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
c）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
d）并非所有的对象都可以序列化，,至于为什么不可以，有很多原因了,比如：
1.安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输 等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
2. 资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分 配，而且，也是没有必要这样实现。


JAVA中浅复制与深复制

1．浅复制与深复制概念
⑴浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

⑵深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

2．Java的clone()方法
⑴clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。

⑵Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
②在派生类中覆盖基类的clone()方法，并声明为public。
③在派生类的clone()方法中，调用super.clone()。
④在派生类中实现Cloneable接口。

说明：
①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。
②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明之。

测试引用变量序列化： 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class TestSeriable
{
    public static void main(String[] args)
    {
        B b = new B("this is b");
        A a = new A("this is a", b);

        System.out.println(a.getName());
        System.out.println(a.getB().getName());
        System.out.println("***************");

        try
        {
            ByteArrayOutputStream stream = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(stream);
            out.writeObject(a);
            byte[] alBytes = stream.toByteArray();

            A aa = (A) new ObjectInputStream(new ByteArrayInputStream(alBytes)).readObject();
            System.out.println(a.getName());
            System.out.println(a.getB().getName());
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        catch (ClassNotFoundException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class A implements Serializable
{
    String name;
    B b;

    public A(String name, B b)
    {
        this.name = name;
        this.b = b;
    }

    public String getName()
    {
        return name;
    }

    public B getB()
    {
        return b;
    }
}

class B implements Serializable
{
    String name;

    public B(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }
}



1.java里的clone分为：
A:浅复制（浅克隆）: 浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
b:深复制（深克隆）：深复制把要复制的对象所引用的对象都复制了一遍。
Java中对象的克隆,为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。必须要遵循下面三点
1.在派生类中覆盖基类的clone()方法，并声明为public【Object类中的clone()方法为protected的】。
2.在派生类的clone()方法中，调用super.clone()。
3.在派生类中实现Cloneable接口。

Object类里的clone方法是浅复制（浅克隆）

浅复制（浅克隆）的例子如下： 

//浅复制（浅克隆）: 浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
//深复制（深克隆）：深复制把要复制的对象所引用的对象都复制了一遍。
//
//Java中对象的克隆,为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。必须要遵循下面三点
//1.在派生类中覆盖基类的clone()方法，并声明为public【Object类中的clone()方法为protected的】。
//2.在派生类的clone()方法中，调用super.clone()。
//3.在派生类中实现Cloneable接口。

//Object类里的clone方法是浅复制（浅克隆）
public class CloneTest
{

    public static void main(String[] args) throws Exception
    {
        // teacher对象将被clone出来的Student对象共享.
        Teacher teacher = new Teacher();
        teacher.setAge(40);
        teacher.setName("Teacher zhang");

        Student student1 = new Student();
        student1.setAge(20);
        student1.setName("zhangsan");
        student1.setTeacher(teacher);

        // 复制出来一个对象student2
        Student student2 = (Student) student1.clone();
        System.out.println(student2.getAge());
        System.out.println(student2.getName());

        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
        System.out.println(student1.getTeacher().getAge());
        System.out.println(student1.getTeacher().getName());

        // 修改student2的引用对象
        student2.getTeacher().setAge(50);
        student2.getTeacher().setName("Teacher Li");

        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
        System.out.println(student1.getTeacher().getAge());
        System.out.println(student1.getTeacher().getName());
    }
}

class Teacher
{
    public int age;
    public 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;
    }

}

class Student implements Cloneable
{

    public int age;
    public String name;
    public Teacher teacher;

    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;
    }

    public Teacher getTeacher()
    {
        return teacher;
    }

    public void setTeacher(Teacher teacher)
    {
        this.teacher = teacher;
    }

    @Override
    public Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }

}


输出结果为：
20
zhangsan
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang
~~~~~~~~~~~~~~~~~~~~~~
50
Teacher Li


2.深复制（深Clone）例子： 


package com.test1;

//深clone
public class DeepCloneTest {

	public static void main(String[] args) throws Exception{
		//teacher对象将不被clone出来的Student对象共享.
		Teacher teacher = new Teacher();
		teacher.setAge(40);
		teacher.setName("Teacher zhang");

		Student student1 = new Student();
		student1.setAge(20);
		student1.setName("zhangsan");
		student1.setTeacher(teacher);

		//复制出来一个对象student2
		Student student2 = (Student)student1.clone();
		System.out.println(student2.getAge());
		System.out.println(student2.getName());


		System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println(student1.getTeacher().getAge());
		System.out.println(student1.getTeacher().getName());


		//修改student2的引用对象
		student2.getTeacher().setAge(50);
		student2.getTeacher().setName("Teacher Li");

		System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println(student1.getTeacher().getAge());
		System.out.println(student1.getTeacher().getName());
	}
}

class Teacher implements Cloneable{
	public int age;
	public 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;
	}
	@Override
	public Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

}

class Student implements Cloneable{

	public int age ;
	public String name;
	public Teacher teacher;
	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;
	}
	public Teacher getTeacher() {
		return teacher;
	}
	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}
	@Override
	public Object clone() throws CloneNotSupportedException {
		Student student = (Student)super.clone();
		//将引用的对象teacher也clone下
		student.setTeacher((Teacher)(student.getTeacher().clone()));
		return student;
	}


}

输出结果为：
20
zhangsan
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang

3.利用序列化来做深复制,把对象写到流里的过程是序列化（Serilization）过程，而把对象从流中读出来的过程则叫做反序列化（Deserialization）过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。，利用这个特性，可以做深拷贝 

package com.test3;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
//利用序列化来做深复制
//深clone
public class DeepCloneTest {

	public static void main(String[] args) throws Exception{
		//teacher对象将不被clone出来的Student对象共享.
		Teacher teacher = new Teacher();
		teacher.setAge(40);
		teacher.setName("Teacher zhang");

		Student student1 = new Student();
		student1.setAge(20);
		student1.setName("zhangsan");
		student1.setTeacher(teacher);

		//复制出来一个对象student2
		Student student2 = (Student)student1.deepCopy();
		System.out.println(student2.getAge());
		System.out.println(student2.getName());


		System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println(student1.getTeacher().getAge());
		System.out.println(student1.getTeacher().getName());


		//修改student2的引用对象
		student2.getTeacher().setAge(50);
		student2.getTeacher().setName("Teacher Li");

		System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
		System.out.println(student1.getTeacher().getAge());
		System.out.println(student1.getTeacher().getName());
	}
}

class Teacher implements Serializable{

	private static final long serialVersionUID = -8834559347461591191L;

	public int age;
	public 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;
	}

}

class Student implements Serializable{

	//serialVersionUID 如果你的对象序列化后存到硬盘上面后，可是后来你却更改了类的field(增加或减少或改名)，当你反序列化时，就会出现Exception的，这样就会造成不兼容性的问题。 
	//但当serialVersionUID相同时，它就会将不一样的field以type的缺省值赋值(如int型的是0,String型的是null等)，这个可以避开不兼容性的问题。所以最好给serialVersionUID赋值
	private static final long serialVersionUID = 7991552226614088458L;

	public int age ;
	public String name;
	public Teacher teacher;
	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;
	}
	public Teacher getTeacher() {
		return teacher;
	}
	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}

	public Object deepCopy() throws Exception{
		//将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
		ByteArrayOutputStream bos = new ByteArrayOutputStream();

		ObjectOutputStream oos = new ObjectOutputStream(bos);

		oos.writeObject(this);

		//将流序列化成对象
		ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());

		ObjectInputStream ois = new ObjectInputStream(bis);

		return ois.readObject();
	}


}


输出结果为：
20
zhangsan
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang
~~~~~~~~~~~~~~~~~~~~~~
40
Teacher zhang
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值