`
coach
  • 浏览: 386756 次
  • 性别: Icon_minigender_2
  • 来自: 印度
社区版块
存档分类
最新评论

浅深克隆和序列化总结

JVMSocketthread 
阅读更多
序列化的原则：并不是实现序列化的类中所有的属性都可以被自动的序列化。1.父类没有实现序列化，子类序列化时，继承父类的属性则不会被序列 化。2.static类型不能被序列化。  why？3.transient关键字修饰的属性和方法不能被序列化。因此有时候有些属性或方法不想被序列化时，可以用transient将其限制。那么 一般什么属性最好不要被序列化呢？1.线程的相关属性。2.要访问IO，本地资源，网络资源的属性。3.没有实现序列化的属性既没有实现序列化，又没有用 transient标识的，会抛出NotSerializableException。

相关注意事项    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


分享到：
| java序列化java.io.Externalizable
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    克隆和序列化(Java )

    在Java编程语言中，克隆和序列化是两个...总结来说，Java中的克隆和序列化是两个强大的工具，它们在数据持久化、对象复制以及网络通信等方面有着广泛的应用。理解和熟练掌握这两个概念，对于Java开发者来说至关重要。

    java序列化和反序列化的方法

    java 序列化和反序列化的方法 Java 序列化和反序列化是 Java 语言中的一种机制，用于将对象转换为字节流，以便在网络上传输或存储。序列化是将对象转换为字节流的过程，而反序列化是将字节流转换回对象的过程。 在...

    KryoJava序列化和克隆框架具有快速高效自动的特点

    Kryo是一个针对Java的高性能对象图序列化框架，由Esoteric Software开发，其特性包括快速、高效以及自动处理，使得在内存序列化和反序列化过程中能实现卓越的性能。 **Kryo的核心特性** 1. **速度与效率**：Kryo...

    关于 Java 对象序列化您不知道的 5 件事

    虽然序列化和克隆都能创建对象的副本，但二者有本质区别。序列化涉及将对象转换为字节流，而克隆是直接创建一个与原对象具有相同属性的新对象，通常通过实现`Cloneable`接口并覆盖`clone()`方法来实现。 9. **序列...

    java序列化原理与算法

    在现代软件开发中，尤其是在网络通信和数据持久化领域，对象的序列化与反序列化扮演着至关重要的角色。Java作为一种广泛应用的编程语言，提供了强大的内置支持来实现序列化功能。本文将深入探讨Java序列化的基本概念...

    序列化与持久化相同点跟不同点

    5. **对象克隆：** 可以通过序列化和反序列化实现对象的深度复制。 #### 三、序列化与持久化的相似之处 尽管序列化和持久化在本质上有所区别，但它们之间的相似之处也非常明显： 1. **数据转换：** 无论是序列化...

    Java中对象的序列化方式克隆详解

    深克隆通过序列化和反序列化实现，首先将对象写入`ByteArrayOutputStream`，然后从`ByteArrayInputStream`中读取，从而创建一个新的对象。这种方式可以确保对象及其引用的所有对象都被复制，形成一个新的独立的实例...

    swift-Swift的MsgPack序列化和反序列化器

    在Swift中，使用MsgPack进行序列化和反序列化能够提高应用性能，因为与JSON等文本格式相比，二进制格式通常占用更少的空间，处理速度更快。 MsgPack的核心概念包括基本类型（如整数、浮点数、布尔值和字符串）以及...

    关于Java对象序列化您不知道的5件事Java开发Java

    序列化和对象的浅复制（克隆）都是保存对象状态的方式，但两者有本质区别。序列化是将整个对象转换为字节流，而克隆是创建对象的一个副本，通常只复制对象的直接属性，不涉及深层引用。 了解以上知识点后，Java...

    Java对象序列化

    3. **对象克隆**：通过序列化和反序列化实现对象的深度克隆。 4. **缓存机制**：将对象状态存储到磁盘或内存中，以提高性能。 #### 三、序列化实现机制 Java提供了两种主要的序列化方式： 1. **标准序列化**（`...

    白菜和甘蓝类黄酮3‘-羟化酶基因的克隆和序列分析

    本研究中，研究者们对白菜和甘蓝类黄酮3'-羟化酶基因进行了克隆和序列分析，成功克隆了全长为3067bp的白菜型油菜F3'H基因（BrF3'H）和全长为3128bp的羽衣甘蓝F3'H基因（BoF3'H）。这两位基因都包含有3个标准剪接的...

    罗田甜柿乙醇脱氢酶（Adh）基因片段的克隆和序列分析

    罗田甜柿乙醇脱氢酶（Adh）基因片段的克隆和序列分析，杜晓云，张青林，利用同源克隆法首次从柿基因组中克隆到乙醇脱氢酶基因的部分片段，命名为DKAdh1。测序及序列分析表明，克隆片段长1,305bp，类典型的10

    Java对象（最后面是序列化的知识）1

    Java编程语言中，对象的创建和管理涉及到一系列...总结来说，Java对象的生命周期涉及类加载、初始化，以及对象的创建、克隆、序列化和反序列化等步骤，每一步都可能需要特定的处理和优化，以满足不同的需求和安全考虑。

    java.io.Serializable序列化问题

    使用 `Externalizable` 接口的主要优点在于可以更精确地控制序列化和反序列化过程，这对于需要自定义序列化逻辑的对象非常有用。 #### 六、序列化中的注意事项 - **`transient` 关键字**：使用 `transient` 可以...

    苏云金芽胞杆菌aiiA基因的克隆和序列分析

    苏云金芽胞杆菌aiiA基因的克隆和序列分析，黄天培，潘洁茹，利用pMD18-T克隆载体从苏云金芽胞杆菌菌株WB12中克隆了aiiA基因。测序结果表明，该基因（GenBank登录号为DQ000642）由753个碱基组成，编码含

    java序列化

    - **对象克隆**：通过序列化和反序列化来实现对象的深度克隆。 #### 三、实现序列化的步骤 要使一个Java类支持序列化，最简单的方法是让它实现`java.io.Serializable`接口。实现此接口的类意味着它可以被序列化。 ...

    java中对象的序列化与反序列化深入讲解

    3. **深度克隆**：通过序列化和反序列化，可以实现对象的深拷贝，即创建一个与原对象完全相同的新对象，其内部状态与原对象一致，不受原对象后续修改的影响。 在实际使用中，需要注意的是，序列化可能会暴露对象的...

Magicbox
Global site tag (gtag.js) - Google Analytics