脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java复制对象并不想复制其中的空值属性

Java复制一个对象并且不想复制其中的空值属性问题

 更新时间：2023年08月26日 09:45:38   作者：哆啦T梦  
这篇文章主要介绍了Java复制一个对象并且不想复制其中的空值属性问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

Java复制一个对象并且不想复制其中的空值属性

Java复制一个对象并且不想复制其中的空值属性，你可以通过几种方式来实现。

Java类库

1.使用Java中的BeanUtils类。

这个类提供了一个copyProperties()方法，可以用来复制一个对象的属性到另一个对象。

默认情况下，copyProperties()方法会复制所有属性，包括空值属性。

但是，你可以使用BeanUtils中的BeanUtilsBean类来设置nullsAreIgnored属性为true，这样就可以忽略掉源对象中的空值属性。

示例代码如下：

BeanUtilsBean beanUtilsBean = BeanUtilsBean.getInstance();
beanUtilsBean.getConvertUtils().register(false, true, 0);
beanUtilsBean.copyProperties(destObject, srcObject);

第三方库

1.Apache Commons Lang库中的ObjectUtils类。

这个类提供了一些有用的方法来操作对象，包括复制对象并忽略空值属性的方法。

示例代码如下：

ObjectUtils.clone(srcObject, new CloneNullsStrategy());

其中，CloneNullsStrategy类是一个实现了org.apache.commons.lang3.ObjectUtils.Null的自定义策略，它用于在复制对象时忽略空值属性。

2.hutool的BeanUtil类。

示例代码如下：

 //null,表示无限制，true表示若父类中属性值为空则忽略，不传给子类
 private final CopyOptions copyOption = CopyOptions.create(null, true);
 BeanUtil.copyProperties(srcObject, destObject, copyOption);

Java对象复制的三种方式

在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能 会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。

例如下面程序展示的情况：

class Student {  
    private int number;  
    public int getNumber() {  
        return number;  
    }  
    public void setNumber(int number) {  
        this.number = number;  
    }  
}  
public class Test {   
    public static void main(String args[]) {  
        Student stu1 = new Student();  
        stu1.setNumber(12345);  
        Student stu2 = stu1;  
        stu1.setNumber(54321);  
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
    }  
}

结果：

学生1:54321
学生2:54321

为什么改变学生2的学号，学生1的学号也发生了变化呢？

原因出在(stu2 = stu1) 这一句。该语句的作用是将stu1的引用赋值给stu2，这样，stu1和stu2指向内存堆中同一个对象。

那么，怎么能干干净净清清楚楚地复制一个对象呢。在 Java语言中，用简单的赋值语句是不能满足这种需求的。

要满足这种需求有很多途径：

（1）将A对象的值分别通过set方法加入B对象中；

（2）通过重写java.lang.Object类中的方法clone()；

（3）通过org.apache.commons中的工具类BeanUtils和PropertyUtils进行对象复制；

（4）通过序列化实现对象的复制。

将 A 对象的值分别通过 set 方法加入 B 对象中

对属性逐个赋值，本实例为了演示简单就设置了一个属性：

Student stu1 = new Student();  
stu1.setNumber(12345);  
Student stu2 = new Student();  
stu2.setNumber(stu1.getNumber());

我们发现，属性少对属性逐个赋值还挺方便，但是属性多时，就需要一直get、set了，非常麻烦。

重写 java.lang.Object 类中的方法 clone()

先介绍一下两种不同的克隆方法，浅克隆(ShallowClone)和深克隆(DeepClone)。

在Java语言中，数据类型分为值类型（基本数据类型）和引用类型，值类型包括int、double、byte、boolean、char等简单数据类型，引用类型包括类、接口、数组等复杂类型。浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制，下面将对两者进行详细介绍。

浅克隆

一般步骤：

1.被复制的类需要实现Clonenable接口（不实现的话在调用clone方法会抛出CloneNotSupportedException异常)， 该接口为标记接口（不含任何方法）。

2.覆盖clone()方法，访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象（native为本地方法）。

class Student implements Cloneable{  
    private int number;  
    public int getNumber() {  
        return number;  
    }  
    public void setNumber(int number) {  
        this.number = number;  
    }  
    @Override  
    public Object clone() {  
        Student stu = null;  
        try{  
            stu = (Student)super.clone();  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        return stu;  
    }  
}  
public class Test {  
    public static void main(String args[]) {  
        Student stu1 = new Student();  
        stu1.setNumber(12345);  
        Student stu2 = (Student)stu1.clone();  
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
        stu2.setNumber(54321);  
        System.out.println("学生1:" + stu1.getNumber());  
        System.out.println("学生2:" + stu2.getNumber());  
    }  
}

结果：

学生1:12345
学生2:12345
学生1:12345
学生2:54321

在浅克隆中，如果原型对象的成员变量是值类型，将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。

简单来说，在浅克隆中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。

在Java语言中，通过覆盖Object类的clone()方法可以实现浅克隆。

深克隆

package abc;  
class Address {  
    private String add;  
    public String getAdd() {  
        return add;  
    }  
    public void setAdd(String add) {  
        this.add = add;  
    }   
}  
class Student implements Cloneable{  
    private int number;  
    private Address addr;  
    public Address getAddr() {  
        return addr;  
    }  
    public void setAddr(Address addr) {  
        this.addr = addr;  
    }  
    public int getNumber() {  
        return number;  
    }  
    public void setNumber(int number) {  
        this.number = number;  
    }  
    @Override  
    public Object clone() {  
        Student stu = null;  
        try{  
            stu = (Student)super.clone();   //浅复制  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }   
        return stu;  
    }  
}  
public class Test {  
    public static void main(String args[]) {  
        Address addr = new Address();  
        addr.setAdd("杭州市");  
        Student stu1 = new Student();  
        stu1.setNumber(123);  
        stu1.setAddr(addr);  
        Student stu2 = (Student)stu1.clone();  
        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
        addr.setAdd("西湖区");  
        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
    }  
}

结果：

学生1:123,地址:杭州市
学生2:123,地址:杭州市
学生1:123,地址:西湖区
学生2:123,地址:西湖区

怎么两个学生的地址都改变了？

原因是浅复制只是复制了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。

为了达到真正的复制对象，而不是纯粹引用复制。我们需要将Address类可复制化，并且修改clone方法，完整代码如下：

package abc;  
class Address implements Cloneable {  
    private String add;  
    public String getAdd() {  
        return add;  
    }  
    public void setAdd(String add) {  
        this.add = add;  
    }  
    @Override  
    public Object clone() {  
        Address addr = null;  
        try{  
            addr = (Address)super.clone();  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        return addr;  
    }  
}  
class Student implements Cloneable{  
    private int number;  
    private Address addr;  
    public Address getAddr() {  
        return addr;  
    }  
    public void setAddr(Address addr) {  
        this.addr = addr;  
    }  
    public int getNumber() {  
        return number;  
    }  
    public void setNumber(int number) {  
        this.number = number;  
    }  
    @Override  
    public Object clone() {  
        Student stu = null;  
        try{  
            stu = (Student)super.clone();   //浅复制  
        }catch(CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        stu.addr = (Address)addr.clone();   //深度复制  
        return stu;  
    }  
}  
public class Test {  
    public static void main(String args[]) {  
        Address addr = new Address();  
        addr.setAdd("杭州市");  
        Student stu1 = new Student();  
        stu1.setNumber(123);  
        stu1.setAddr(addr);  
        Student stu2 = (Student)stu1.clone();  
        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
        addr.setAdd("西湖区");  
        System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
        System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
    }  
}

结果：

学生1:123,地址:杭州市
学生2:123,地址:杭州市
学生1:123,地址:西湖区
学生2:123,地址:杭州市

在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。

简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将复制。

在Java语言中，如果需要实现深克隆，可以通过覆盖Object类的clone()方法实现，也可以通过序列化(Serialization)等方式来实现。（如果引用类型里面还包含很多引用类型，或者内层引用类型的类里面又包含引用类型，使用clone方法就会很麻烦。这时我们可以用序列化的方式来实现对象的深克隆。

工具类BeanUtils和PropertyUtils进行对象复制

Student stu1 = new Student();  
stu1.setNumber(12345);  
Student stu2 = new Student(); 
BeanUtils.copyProperties(stu2,stu1);

这种写法无论多少种属性都只需要一行代码搞定，很方便吧！除BeanUtils外还有一个名为PropertyUtils的工具类，它也提供copyProperties()方法，作用与BeanUtils的同名方法十分相似，主要的区别在于BeanUtils提供类型转换功能，即发现两个JavaBean的同名属性为不同类型时，在支持的数据类型范围内进行转换，而PropertyUtils不支持这个功能，但是速度会更快一些。

在实际开发中，BeanUtils使用更普遍一点，犯错的风险更低一点。

通过序列化实现对象的复制

序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个拷贝，而原对象仍然存在于内存中。

通过序列化实现的拷贝不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流里将其读出来，可以实现深克隆。

需要注意的是能够实现序列化的对象其类必须实现Serializable接口，否则无法实现序列化操作。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • idea perttier的使用和缩进改为4不成功问题及解决

    idea perttier的使用和缩进改为4不成功问题及解决

    这篇文章主要介绍了idea perttier的使用和缩进改为4不成功问题及解决,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-05-05
  • Java多线程之线程状态详解

    Java多线程之线程状态详解

    这篇文章主要介绍了Java多线程 线程状态原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2021-09-09
  • Spring中@Conditional注解的详细讲解及示例

    Spring中@Conditional注解的详细讲解及示例

    这篇文章主要介绍了Spring中@Conditional注解的详细讲解及示例,@Conditional是Spring4新提供的注解,它的作用是按照一定的条件进行判断,满足条件给容器注册bean,需要的朋友可以参考下
    2023-11-11
  • SpringBoot添加License的多种方式

    SpringBoot添加License的多种方式

    License指的是版权许可证，当我们开发完系统后，如果不想让用户一直白嫖使用，比如说按时间续费，License的作用就有了。我们可以给系统指定License的有效期，控制系统的可用时间。
    2021-06-06
  • dom4j读取XML文件详解

    dom4j读取XML文件详解

    这篇文章主要为大家详细介绍了dom4j读取XML文件的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2017-11-11
  • Java AQS 原理与 ReentrantLock 实现方法

    Java AQS 原理与 ReentrantLock 实现方法

    AQS 的作用是解决同步器的实现问题,它将复杂的同步器实现分解为简单的框架方法,开发者只需要实现少量特定的方法就能快速构建出可靠的同步器,这篇文章主要介绍Java AQS原理与ReentrantLock实现,需要的朋友可以参考下
    2025-03-03
  • mybatis TypeHandler注入spring的依赖方式

    mybatis TypeHandler注入spring的依赖方式

    这篇文章主要介绍了mybatis TypeHandler注入spring的依赖方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-01-01
  • SpringBoot配置Email发送功能实例

    SpringBoot配置Email发送功能实例

    本篇文章主要介绍了SpringBoot配置Email发送功能实例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-04-04
  • Java+MySQL 图书管理系统

    Java+MySQL 图书管理系统

    这篇文章是BUFFER.pwn同学分享的基于Java与MySQL的图书管理系统，需要的朋友可以参考一下
    2021-04-04
  • Java工厂模式的深入了解

    Java工厂模式的深入了解

    这篇文章主要为大家介绍了Java工厂模式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助
    2022-01-01

最新评论