Java的浅拷贝和深拷贝

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量375 收藏 1
点赞数
文章标签： java string class object import exception
 

浅拷贝：把一个对象中所有的非static成员变量(包括对其它对象的引用，java中的引用相当于C/C++中的指针变量)都拷贝一遍，而不拷贝引用所指向的对象

深拷贝：把一个对象中所有的非static成员变量(包括对其它对象的引用)都拷贝一遍，引用所指向的对象也拷贝一份

一个类的对象如果想要具有拷贝的功能，比如符合如下条件：

   1.必须实现Cloneable接口(这个接口中没有定义方法，叫做标记接口)

   2.重写Object类的clone()方法，该方法实现的是浅拷贝

   3.在该类的clone()方法中的第一句，比如调用super.clone()来调用Object的clone()方法来实现拷贝

浅拷贝的例子：

public class CloneTest  
{  
    public static void main(String[] args)  
    {  
        Student s1 = new Student();  
        s1.setAge(20);  
        s1.setName("wudi");  
        School school = new School();  
        school.setName("Peiyang University");  
        school.setBornYear(1895);  
        s1.setSchool(school);  
        System.out  
                .println("s1:" + s1.getName() + " " + s1.getAge() + " " 
                        + s1.getSchool().getName() + " " 
                        + s1.getSchool().getBornYear());  
          
        try 
        {  
            //拷贝一个学生  
            Student s2 = (Student)s1.clone();  
            s2.setAge(21);  
            s2.setName("WUDI");  
            System.out  
            .println("s2:" + s2.getName() + " " + s2.getAge() + " " 
                    + s2.getSchool().getName() + " " 
                    + s2.getSchool().getBornYear());  
              
            System.out.println("after s2 changing some property:");  
            //通过学生s2改变了他所在学校的名称和成立时间  
            s2.getSchool().setName("Tianjin University");  
            s2.getSchool().setBornYear(1951);  
              
              
            System.out  
            .println("s1:" + s1.getName() + " " + s1.getAge() + " " 
                    + s1.getSchool().getName() + " " 
                    + s1.getSchool().getBornYear());  
            System.out  
            .println("s2:" + s2.getName() + " " + s2.getAge() + " " 
                    + s2.getSchool().getName() + " " 
                    + s2.getSchool().getBornYear());   
               
}   
        catch (CloneNotSupportedException e)  
        {  
            e.printStackTrace();  
        }  
    }  
}  
class School  
{  
    private String name;  
    private int bornYear;  
    public String getName()  
    {  
        return name;  
    }  
    public void setName(String name)  
    {  
        this.name = name;  
    }  
    public int getBornYear()  
    {  
        return bornYear;  
    }  
    public void setBornYear(int bornYear)  
    {  
        this.bornYear = bornYear;  
    }  
}  
class Student implements Cloneable  
{  
    private int age;  
    private String name;  
    private School school;  
    public School getSchool()  
    {  
        return school;  
    }  
    public void setSchool(School school)  
    {  
        this.school = school;  
    }  
    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 
    protected Object clone() throws CloneNotSupportedException  
    {  
        return super.clone();  
    }  
}  
package com.test;
public class CloneTest
{
 public static void main(String[] args)
 {
  Student s1 = new Student();
  s1.setAge(20);
  s1.setName("wudi");
  School school = new School();
  school.setName("Peiyang University");
  school.setBornYear(1895);
  s1.setSchool(school);
  System.out
    .println("s1:" + s1.getName() + " " + s1.getAge() + " "
      + s1.getSchool().getName() + " "
      + s1.getSchool().getBornYear());
  
  try
  {
   //拷贝一个学生
   Student s2 = (Student)s1.clone();
   s2.setAge(21);
   s2.setName("WUDI");
   System.out
   .println("s2:" + s2.getName() + " " + s2.getAge() + " "
     + s2.getSchool().getName() + " "
     + s2.getSchool().getBornYear());
   
   System.out.println("after s2 changing some property:");
   //通过学生s2改变了他所在学校的名称和成立时间
   s2.getSchool().setName("Tianjin University");
   s2.getSchool().setBornYear(1951);
      
   System.out
   .println("s1:" + s1.getName() + " " + s1.getAge() + " "
     + s1.getSchool().getName() + " "
     + s1.getSchool().getBornYear());
   System.out
   .println("s2:" + s2.getName() + " " + s2.getAge() + " "
     + s2.getSchool().getName() + " "
     + s2.getSchool().getBornYear());
   
}
  catch (CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
 }
}
class School
{
 private String name;
 private int bornYear;
 public String getName()
 {
  return name;
 }
 public void setName(String name)
 {
  this.name = name;
 }
 public int getBornYear()
 {
  return bornYear;
 }
 public void setBornYear(int bornYear)
 {
  this.bornYear = bornYear;
 }
}
class Student implements Cloneable
{
 private int age;
 private String name;
 private School school;
 public School getSchool()
 {
  return school;
 }
 public void setSchool(School school)
 {
  this.school = school;
 }
 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
 protected Object clone() throws CloneNotSupportedException
 {
  return super.clone();
 }
} 

从运行结果可以看出，通过学生s2将其引用school所指向的对象的name和bornYear属性改变，相应的s1的也被改变，这说明学生s1和学生s2里面的school引用指向的始终是同一个School对象。这就是浅拷贝的含义。

深拷贝的例子：

public class CloneTest  
{  
    public static void main(String[] args)  
    {  
        Student s1 = new Student();  
        s1.setAge(20);  
        s1.setName("wudi");  
        School school = new School();  
        school.setName("Peiyang University");  
        school.setBornYear(1895);  
        s1.setSchool(school);  
        System.out  
                .println("s1:" + s1.getName() + " " + s1.getAge() + " " 
                        + s1.getSchool().getName() + " " 
                        + s1.getSchool().getBornYear());  
          
        try 
        {  
            //拷贝一个学生  
            Student s2 = (Student)s1.clone();  
            s2.setAge(21);  
            s2.setName("WUDI");  
            System.out  
            .println("s2:" + s2.getName() + " " + s2.getAge() + " " 
                    + s2.getSchool().getName() + " " 
                    + s2.getSchool().getBornYear());  
              
            System.out.println("after s2 changing some property:");  
            //通过学生s2改变了他所在学校的名称和成立时间  
            s2.getSchool().setName("Tianjin University");  
            s2.getSchool().setBornYear(1951);  
              
              
            System.out  
            .println("s1:" + s1.getName() + " " + s1.getAge() + " " 
                    + s1.getSchool().getName() + " " 
                    + s1.getSchool().getBornYear());  
            System.out  
            .println("s2:" + s2.getName() + " " + s2.getAge() + " " 
                    + s2.getSchool().getName() + " " 
                    + s2.getSchool().getBornYear());   
}   
        catch (CloneNotSupportedException e)  
        {  
            e.printStackTrace();  
        }  
    }  
}  
class School implements Cloneable  
{  
    private String name;  
    private int bornYear;  
    public String getName()  
    {  
        return name;  
    }  
    public void setName(String name)  
    {  
        this.name = name;  
    }  
    public int getBornYear()  
    {  
        return bornYear;  
    }  
    public void setBornYear(int bornYear)  
    {  
        this.bornYear = bornYear;  
    }  
      
    @Override 
    protected Object clone() throws CloneNotSupportedException  
    {  
        return super.clone();  
    }  
}  
class Student implements Cloneable  
{  
    private int age;  
    private String name;  
    private School school;  
    public School getSchool()  
    {  
        return school;  
    }  
    public void setSchool(School school)  
    {  
        this.school = school;  
    }  
    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 
    protected Object clone() throws CloneNotSupportedException  
    {  
        Student s2 = (Student)super.clone();  
          
        //将school所引用的对象也拷贝一份，并且让学生s2去引用这个新的School对象  
        s2.setSchool((School)school.clone());  
          
        return s2;  
    }  
} 
package com.test;
public class CloneTest
{
 public static void main(String[] args)
 {
  Student s1 = new Student();
  s1.setAge(20);
  s1.setName("wudi");
  School school = new School();
  school.setName("Peiyang University");
  school.setBornYear(1895);
  s1.setSchool(school);
  System.out
    .println("s1:" + s1.getName() + " " + s1.getAge() + " "
      + s1.getSchool().getName() + " "
      + s1.getSchool().getBornYear());
  
  try
  {
   //拷贝一个学生
   Student s2 = (Student)s1.clone();
   s2.setAge(21);
   s2.setName("WUDI");
   System.out
   .println("s2:" + s2.getName() + " " + s2.getAge() + " "
     + s2.getSchool().getName() + " "
     + s2.getSchool().getBornYear());
   
   System.out.println("after s2 changing some property:");
   //通过学生s2改变了他所在学校的名称和成立时间
   s2.getSchool().setName("Tianjin University");
   s2.getSchool().setBornYear(1951);
   
   System.out
   .println("s1:" + s1.getName() + " " + s1.getAge() + " "
     + s1.getSchool().getName() + " "
     + s1.getSchool().getBornYear());
   System.out
   .println("s2:" + s2.getName() + " " + s2.getAge() + " "
     + s2.getSchool().getName() + " "
     + s2.getSchool().getBornYear());
 }
  catch (CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
 }
}
class School implements Cloneable
{
 private String name;
 private int bornYear;
 public String getName()
 {
  return name;
 }
 public void setName(String name)
 {
  this.name = name;
 }
 public int getBornYear()
 {
  return bornYear;
 }
 public void setBornYear(int bornYear)
 {
  this.bornYear = bornYear;
 }
 
 @Override
 protected Object clone() throws CloneNotSupportedException
 {
  return super.clone();
 }
}
class Student implements Cloneable
{
 private int age;
 private String name;
 private School school;
 public School getSchool()
 {
  return school;
 }
 public void setSchool(School school)
 {
  this.school = school;
 }
 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
 protected Object clone() throws CloneNotSupportedException
 {
  Student s2 = (Student)super.clone();
  
  //将school所引用的对象也拷贝一份，并且让学生s2去引用这个新的School对象
  s2.setSchool((School)school.clone());
  
  return s2;
 }
}
 该段代码让School类(被引用的类)也实现了Cloneable接口，并且也重写了clone()方法。然后改写了Student的clone()方法。从结果可以看出，学生s2改变其引用的学校的属性，不会影响到学生s1所属的学校的属性，这就是深拷贝的含义。还可以通过序列化来实现对象的深拷贝，一个对象被序列化时会将对象和对象内部引用的其他的对象(递归下去)一起序列化一个对象如果想要被序列化，那么必须实现Serializable接口，这个接口也没有定义任何方法，也是一个marker interface

将前一个例子进行改写，用序列化的方法实现深拷贝的代码如下：

view plaincopy to clipboardprint?
package com.test;  
import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
import java.io.Serializable;  
public class CloneTest  
{  
    public static void main(String[] args) throws Exception  
    {  
        Student s1 = new Student();  
        s1.setAge(20);  
        s1.setName("wudi");  
        School school = new School();  
        school.setName("Peiyang University");  
        school.setBornYear(1895);  
        s1.setSchool(school);  
        System.out  
                .println("s1:" + s1.getName() + " " + s1.getAge() + " " 
                        + s1.getSchool().getName() + " " 
                        + s1.getSchool().getBornYear());  
          
        try 
        {  
            //拷贝一个学生  
            Student s2 = (Student)s1.deepClone();  
            s2.setAge(21);  
            s2.setName("WUDI");  
            System.out  
            .println("s2:" + s2.getName() + " " + s2.getAge() + " " 
                    + s2.getSchool().getName() + " " 
                    + s2.getSchool().getBornYear());  
              
            System.out.println("after s2 changing some property:");  
            //通过学生s2改变了他所在学校的名称和成立时间  
            s2.getSchool().setName("Tianjin University");  
            s2.getSchool().setBornYear(1951);   
                
            System.out  
            .println("s1:" + s1.getName() + " " + s1.getAge() + " " 
                    + s1.getSchool().getName() + " " 
                    + s1.getSchool().getBornYear());  
            System.out  
            .println("s2:" + s2.getName() + " " + s2.getAge() + " " 
                    + s2.getSchool().getName() + " " 
                    + s2.getSchool().getBornYear());   
      
        }   
        catch (CloneNotSupportedException e)  
        {  
            e.printStackTrace();  
        }  
    }  
}  
 
class School implements Serializable  
{  
    private String name;  
    private int bornYear;  
    public String getName()  
    {  
        return name;  
    }  
    public void setName(String name)  
    {  
        this.name = name;  
    }  
    public int getBornYear()  
    {  
        return bornYear;  
    }  
    public void setBornYear(int bornYear)  
    {  
        this.bornYear = bornYear;  
    }  
}  
class Student implements Serializable  
{  
    private int age;  
    private String name;  
    private School school;  
    public School getSchool()  
    {  
        return school;  
    }  
    public void setSchool(School school)  
    {  
        this.school = school;  
    }  
    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 Object deepClone() throws Exception  
    {  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
          
        //相当于流的连接，将oos流对象连接到baos流对象  
        ObjectOutputStream oos = new ObjectOutputStream(baos);  
          
        oos.writeObject(this);//以上三行将this对象序列化后输出到baos对象中  
          
        //将baos这个流对象转化成字节数组，然后利用这个字节数组构造bais对象  
        //下面三行就是一个反序列化的过程  
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());  
          
        ObjectInputStream ois = new ObjectInputStream(bais);  
          
        return ois.readObject();  
          
    }  
      
} 

圣洁
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA 浅拷贝和深拷贝
skystep的博客
08-07 3677
在 java 中，默认的拷贝指的是类重写 Object 类中的 clone 方法，调用该方法进行拷贝。使用 clone 方法生生成新的对象，此时在堆中产生新的对象，clone 存放了该对象的引用。对浅拷贝进行加强，对象中引用属性进行 clone 操作，以下例子 User 类 clone 的时候也对 animal 进行拷贝。深拷贝相对于浅拷贝而言，会对所有数据类型都进行拷贝一份，包括这个对象所包含的内部对象。User 类实现 Serializable 接口，对堆区中的实例进行读写，从而实现对实例的全部拷贝。.
java浅拷贝和深拷贝
qq_38976745的博客
11-30 480
这里写自定义目录标题什么是拷贝关于浅拷贝关于深拷贝简单实现深拷贝、浅拷贝实现浅拷贝实现深拷贝拷贝和new创建对象的性能简单对比欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 什么是拷贝 面试中
java浅拷贝和深拷贝的区别_Java 浅拷贝与深拷贝的区别
weixin_28674303的博客
02-13 661
浅拷贝什么是浅拷贝被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。浅拷贝实例public class ShallowCopy {public static void main(String[] args) throws CloneNotSup...
Java 浅拷贝和深拷贝
qq_40679774的博客
04-20 553
浅拷贝和深拷贝 代码地址 浅拷贝：直接复制了对象A地址给另一个对象B。修改B，A也会跟着改变。 深拷贝：复制了对象A的值给另一个对象B，这两个对象没有任何关系指向不同的地址。修改其中一个并不会对另一个造成影响。 浅拷贝 直接赋值 ShallowCopy.java文件中的assign方法。 重写clone() 注意这个类得实现Cloneable接口 clone 算是半深半浅吧。通过重写clone方法来实现拷贝可以做到对对象中基本数据类型（int,char,boolean等）及其包装类型（String、Inte
java干货 浅拷贝和深拷贝
qq_51305563的博客
06-27 1766
java干货 浅拷贝和深拷贝
Java浅拷贝和深拷贝
yingfeng612的专栏
02-24 412
java拷贝分为两种：引用拷贝和对象拷贝引用拷贝：不需要申请堆内存，只是将拷贝后的的引用指向原来的对象；对象拷贝：需要申请堆内存，是一个新的对象；（对象拷贝分为深拷贝和浅拷贝），下面予以说明。1.准备工作。类：public class Address implements Serializable{ }public class User implements Cloneable,Serializ...
Java浅拷贝和深拷贝的方式
smietao的博客
04-26 3283
Java浅拷贝和深拷贝的方式 的简单介绍
Java中浅拷贝和深拷贝的区别
BlueProtocolBlog
10-27 1877
被拷贝的对象的所有属性值都与原来的对象相同，而对象的所有属性引用仍然指向原来的属性所指向的内存地址。需要注意的是cloneObj == obj 返回的是false，所以使用的Object的clone（）是浅拷贝。：被拷贝的对象的所有属性值都与原来的对象相同，而对象的所有属性的引用都指向新的克隆出来的属性的内存地址。深拷贝的实现方式一般有三种，第一种是使用构造器来实现，这个先不说。
Java中的浅拷贝和深拷贝
qq15035899256的博客
10-07 958
本文是JavaSE的学习，认识什么是拷贝，浅拷贝和深拷贝的区别，实现深拷贝的两种方式。之后的学习内容将持续更新！！！
Java的浅拷贝与深拷贝详细解析
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
10-11 1447
若是拷贝的类中仅仅是一些基本类型，那么直接使用clone()方法。若是有多个自定义类或其他没有实现Cloneable接口的jdk核心类，那么建议使用反序列化的方式。使用默认的clone()方法速度最快。
java深入理解浅拷贝和深拷贝
12-21
在Java编程中，深入理解浅拷贝和深拷贝是非常重要的概念，特别是在处理对象复制时。浅拷贝和深拷贝的区别在于复制对象时对内存中数据的处理方式。 浅拷贝（Shallow Copy）指的是创建一个新的对象，该对象与原对象...
《剑指offer》Java浅拷贝和深拷贝.pdf
01-04
Java中的对象拷贝是一个重要的...总之，理解Java中的浅拷贝和深拷贝对于编写可维护和可扩展的代码至关重要，尤其是在处理复杂的数据结构和对象依赖时。掌握这些概念可以帮助你更好地应对面试挑战和解决实际编程问题。
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
总的来说，Java中的深拷贝和浅拷贝是处理对象复制时的关键概念。正确理解和使用它们可以避免不必要的错误，特别是在处理复杂的对象结构时。在编写代码时，一定要根据实际情况来决定使用哪种拷贝方式，以满足程序的...
结合JVM解读浅拷贝和深拷贝
12-20
总的来说，了解`Cloneable`接口、`Object.clone()`方法以及浅拷贝和深拷贝的概念对于编写高质量、健壮的Java代码是至关重要的。正确使用这些机制能够帮助开发者创建可维护、可扩展的系统，并确保数据的正确复制和...
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅拷贝的两种实现方法。 一、浅拷贝 浅拷贝...
golang 接口
m0_70982551的博客
07-24 929
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 504
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 619
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 581
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值