Java基础——拷贝

最新推荐文章于 2024-07-14 21:34:05 发布
最新推荐文章于 2024-07-14 21:34:05 发布
阅读量260 收藏
点赞数
分类专栏： java基础备忘，自用 java基础备忘

引用拷贝，只是单纯的将一个对象赋值给另一个对象，两个对象的引用地址完全一样。

举例：

Teacher teacher = new Teacher("Tom",26);

Teacher otherteacher = teacher;

System.out.println(teacher);

System.out.println(otherteacher);

输出结果：

blog.Teacher@355da254

blog.Teacher@355da254

结果分析：

由输出结果可以看出，他们的地址值是相等的，那么它们其实是同一个对象。两个对象都指向同一个对象。都是new Teacher("Tom",26)。这就是引用拷贝。

 

对象拷贝，是指将对象完全复制，两个对象互不影响，引用地址也不同。并且分为浅拷贝和深拷贝。

举例：

Teacher teacher = new Teacher("Swift",26);
Teacher otherteacher = (Teacher)teacher.clone();
System.out.println(teacher);
System.out.println(otherteacher);
输出结果：

blog.Teacher@355da254

blog.Teacher@4dc63996

结果分析：

由输出结果可以看出，他们的地址是不同的，也就是两个对象都有自己的引用变量。

接下来就是 浅拷贝和深拷贝的区别

被复制对象的所有变量都含有与原来的对象相同的值，

而所有的对其他对象的引用仍然指向原来的对象。

即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。

简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象 

浅拷贝示例：

package blog;

/**
 * Created by 白夜行 on 2017/5/8.
 */
public class ShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("Delacey");
        teacher.setAge(29);

        Student2 student1 = new Student2();
        student1.setName("Dream");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student2 student2 = (Student2) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
        System.out.println("修改老师的信息后-------------");

        // 修改老师的信息
        teacher.setName("Jam");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }

}

class Teacher implements Cloneable
{
    private String name;
    private int age;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

}

class Student2 implements Cloneable
{
    private String name;
    private int age;
    private Teacher teacher;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    public Teacher getTeacher()
    {
        return teacher;
    }

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

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

}

输出结果：

拷贝后

Dream 18

Delacey 29

修改老师的信息后-------------

Jam

Jam

结果分析：

虽然两个student对象是不一样的，但是student引用的teacher是同一个对象，这就是 浅拷贝

深拷贝：

深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

 

简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍，深拷贝都需要对象实现接口(Cloneable或是Serializable)

深拷贝示例一：

package blog;

/**
 * Created by 白夜行 on 2017/5/8.
 */

public class DeepCopy {
    public static void main(String[] args) throws Exception
    {
        Teacher2 teacher = new Teacher2();
        teacher.setName("Delacey");
        teacher.setAge(29);

        Student3 student1 = new Student3();
        student1.setName("Dream");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student3 student2 = (Student3) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
        System.out.println("修改老师的信息后-------------");

        // 修改老师的信息
        teacher.setName("Jam");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }
}

class Teacher2 implements Cloneable {
    private String name;
    private int age;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

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

}

class Student3 implements Cloneable {
    private String name;
    private int age;
    private Teacher2 teacher;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    public Teacher2 getTeacher()
    {
        return teacher;
    }

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

    @Override
    public Object clone() throws CloneNotSupportedException
    {
        // 浅复制时：
        // Object object = super.clone();
        // return object;

        // 改为深复制：
        Student3 student = (Student3) super.clone();
        // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
        student.setTeacher((Teacher2) student.getTeacher().clone());
        return student;
    }

}
输出结果：

拷贝后

Dream 18

Delacey 29

修改老师的信息后-------------

Jam

Delacey

结果分析：

这次不论student还是引用的teacher都是单独的对象，完全不相同。这就是深拷贝

深拷贝示例二：

package blog;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * Created by 白夜行 on 2017/5/13.
 */
public class DeepCopyServiable {
    public static void main(String[] args) throws Exception {
        Teacher3 t = new Teacher3();
        t.setName("Taylor");
        t.setAge(28);

        Student3 s1 = new Student3();
        s1.setAge(20);
        s1.setName("blank space");
        s1.setTeacher(t);

        Student3 s2 = (Student3) s1.deepClone();

        System.out.println("拷贝后:");
        System.out.println(s2.getName());
        System.out.println(s2.getAge());
        System.out.println(s2.getTeacher().getName());
        System.out.println(s2.getTeacher().getAge());
        System.out.println("---------------------------");

        t.setName("swift");

        System.out.println("修改后：");
        System.out.println(s1.getTeacher().getName());
        System.out.println(s2.getTeacher().getName());
    }

}

class Teacher3 implements Serializable
{
    private String name;
    private int age;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

}

class Student3 implements Serializable
{
    private String name;
    private int age;
    private Teacher3 teacher;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    public Teacher3 getTeacher()
    {
        return teacher;
    }

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

    public Object deepClone() throws Exception
    {
        // 序列化
        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();
    }

}
输出结果：

拷贝后:

blank space 20

Taylor 28

---------------------------

修改后：

swift

Taylor

结果分析：

说明序列化的方式实现了对象的拷贝。

可以这么理解，我只是为了自己看起来方便些，重新排版了下。

我发现深拷贝浅拷贝 其实都是需要实现拷贝接口或是序列化接口，并在类中创建一个这样的拷贝方法。感觉对类进行了进一步的拓展。不过对于拷贝这种方法的使用，目前好像没有发现太多的使用场景。如果说得不对，请大家指出，谢谢~

以及的代码及文字都是转至下面这位的博客，感谢~
作者：白夜行515 
来源：CSDN 
原文：https://blog.csdn.net/baiye_xing/article/details/71788741 
版权声明：本文为博主原创文章，转载请附上博文链接！

万载小笼包
关注
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
java编写程序实现文件拷贝_Java IO编程——文件拷贝
weixin_36277054的博客
02-16 2034
在操作系统里面有一个copy命令，这个命令的主要功能是可以实现文件的拷贝处理，现在要求模拟这个命令，通过初始化参数输入拷贝的源文件路径与拷贝的目标路径实现文件的拷贝处理。需求分析：·需要实现文件的拷贝操作，那么这种拷贝就有可能拷贝各种类型的文件，所以肯定使用字节流；·在进行拷贝的时候有可能需要考虑到大文件的拷贝问题；实现方案：·方案一：使用InputStream将全部要拷贝的内容直接读取到程序里面...
浅谈java浅拷贝和深拷贝
weixin_30808693的博客
08-25 95
前言:深拷贝和浅拷贝的区别是什么？ 浅拷贝：被复制的对象的所有变量都含有原来对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之， 浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。深拷贝：被复制对象的所有变量都含有与原来对象相同的值，而那些引用对象的变量将指向被复制过的新对象，而不再是原有 的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。 浅拷贝 　　...
Java 浅拷贝和深拷贝的理解和实现方式
weixin_30662011的博客
10-11 651
Java中的对象拷贝(Object Copy)指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去。举例说明：比如，对象A和对象B都属于类S，具有属性a和b。那么对对象A进行拷贝操作赋值给对象B就是：B.a=A.a; B.b=A.b; 在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用现有对象的部分或全部 数据。 Java中的对象拷贝主要分为：浅拷贝(Shal...
java中的浅拷贝和深拷贝解析
weixin_46410481的博客
09-21 211
java中的浅拷贝和深拷贝解析 任何编程语言中，其实都有浅拷贝和深拷贝的概念，java中也不例外。在对一个现有的对象进行拷贝操作的时候，是有浅拷贝和深拷贝之分的，他们在实际使用中，区别很大，如果对其进行混淆，可能会引发一些难以排查的问题。 本文就在java中的浅拷贝和深拷贝做一个详细的解说。 什么是浅拷贝和深拷贝？ 首先需要明白，浅拷贝和深拷贝都是针对一个已有对象的操作。那先来看看浅拷贝和深拷贝的概念。 在java中，除了基本数据类型（元类型）之外，还存在类的实例对象这个引用数据类型。而一般使用【=】号做赋
【137期】面试官：问点儿基础的，你能说说Java深拷贝和浅拷贝区别吗
良月柒
02-23 538
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 4 分钟。作者：riemannblog.csdn.net/riemann_/article/details/87217...
Java 浅拷贝与深拷贝
u011035026的博客
11-27 8847
1、什么叫Java浅拷贝？  浅拷贝是会将对象的每个属性进行依次复制，但是当对象的属性值是引用类型时，实质复制的是其引用，当引用指向的值改变时也会跟着变化。 2、什么叫Java深拷贝？  深拷贝复制变量值，对于引用数据，则递归至基本类型后，再复制。深拷贝后的对象与原来的对象是完全隔离的，互不影响，对一个对象的修改并不会影响另一个对象。 3、Java浅拷贝和深拷贝的区别是什么？  通俗来讲浅拷贝的复...
java基础——对象的拷贝
ma_xiao_qi的博客
04-07 7019
一、浅拷贝； 规则： 1. 浅拷贝只是拷贝了源对象的地址，所以源对象的值发生变化时，拷贝对象的值也会发生变化。 2. 浅拷贝相当于两个对象共用一套实例。   格式： 类名 对象名1=new 类名(); 类名 对象名2=对象名1; 例如： public class Student { int year,month,day; void set(int x,int y, int z) { year=x; month=y;
Java基础——IO详解
qq_45821255的博客
03-21 3084
本文介绍了IO流的具体内容，包括总结了常用的IO流，把它们做成了体系图。根据体系图分别介绍了它们的使用场景...
Java基础——JVM学习笔记——JAVA内存区域
HFUTJungle的博客
02-05 929
Java内存区域学习笔记
java拷贝_细说 Java 的深拷贝和浅拷贝
weixin_36450668的博客
02-12 122
版权声明：本账号发布文章均来自公众号，承香墨影(cxmyDev)，版权归承香墨影所有。未经允许，不得转载。一、前言任何变成语言中，其实都有浅拷贝和深拷贝的概念，Java 中也不例外。在对一个现有的对象进行拷贝操作的时候，是有浅拷贝和深拷贝之分的，他们在实际使用中，区别很大，如果对其进行混淆，可能会引发一些难以排查的问题。本文就在 Java 中的深拷贝和浅拷贝做一个详细的解说。二、什么是浅拷贝和深拷...
Java深拷贝和浅拷贝（简单易懂）
最新发布
shajjs的博客
07-14 2669
也就是说，浅拷贝只是复制了对象的“顶层”，对于引用类型的成员，实际上复制的是引用，而不是引用所指向的对象。深拷贝（Deep Copy）：创建一个新对象，不仅复制基本数据类型成员的值，对于引用数据类型的成员，也会为其创建新的对象，并复制其内容，使得新对象和原始对象完全独立，修改其中一个对象的引用类型成员不会影响到另一个对象。3.遵循 Java 的异常处理原则：对于可能出现异常的操作，按照良好的编程实践，应当声明可能抛出的异常，以便调用者能够进行适当的异常处理，增强程序的健壮性和可靠性。
Java中的深拷贝与浅拷贝
qq_43460095的博客
07-13 6434
浅拷贝：对基本类型数据进行值传递，对引用类型数据进行引用传递的拷贝深拷贝：对基本类型数据进行值传递，对引用类型数据创建一个新的对象，并复制其内容在Java中，所有的对象都继承自，在类中提供了一个方法来供我们对Java对象进行拷贝： 这个方法是的，所以不需要我们来实现。不过需要注意的是，这个方法还是的，这意味着方法只在包或其子类可见。方法还抛出了一个异常，通过源码注释可以知道，当调用了方法的对象类没有实现接口，或者无法克隆对象的时候，会抛出该异常，也就是说，如果要成功的调用接口，首先该类要实现接口。 Clon
Java基础篇--浅拷贝和深拷贝
m0_74293254的博客
08-13 674
选择使用浅拷贝还是深拷贝取决于实际需求。如果希望复制对象后的修改不会影响原始对象，应该使用深拷贝；如果可以接受复制对象的修改影响原始对象，或者对象较大且复制性能要求高，则可以使用浅拷贝。
java深拷贝和浅拷贝
qq_29087399的博客
07-06 282
java深拷贝和浅拷贝
java中的浅复制和深复制
haidi8
11-17 632
浅复制：只复制基本数据类型，对于引用类型不能实现浅复制的效果。 代码： package com.qf.day13.price.object; public class TestObject { public static void main(String[] args) { Student stu1 = new Student("张三",22); stu1.name="李四"; System.out.println(stu1); Student stu2 =(Student) stu1.c
【Java进阶】java的浅拷贝和深拷贝含义
JeffHan^_^的博客
02-27 220
浅拷贝和深拷贝 引用的复制：不同的引用指向同一个对象 浅复制：只复制当前对象，若对象当中还有其他的引用则不复制 深复制：复制出一个全新的对象，包括里面所有的引用数据类型 下面我们通过代码来理解一下复制的概念 1. 引用的拷贝 //有一个简单的老师类 public class Teacher{ //姓名 private Sting name; //年龄 private int age; //----省去构造方法和getter、setter-------
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值