JAVA对象克隆

最新推荐文章于 2024-04-15 09:52:20 发布
最新推荐文章于 2024-04-15 09:52:20 发布
阅读量368 收藏
点赞数 1
分类专栏： 工具 文章标签： java 数据 对象 存储 克隆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gjm15881133824/article/details/53897224
版权

为什么需要克隆

当我们需要两个数据内容相同，但物理存储地址不同的对象时，就会用到对象了。
（简单点说，就是当你的数据操作需要得到新的保存，但又不想改变原数据时，这时，我们就需要创建这么一个新的对象）

途径

目前，有三种方法来实现对象的克隆

  • 方法映射
  • 序列化和反序列化
  • 实现Cloneable接口

粗暴上代码

方法映射克隆对象

/**
     * 通过方法映射克隆对象
     * 
     * @param t
     *            被克隆对象
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T clone(T t) {
        Class<? extends Object> c = t.getClass();
        Object newT = null;
        try {
            newT = c.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        Field[] fields = c.getDeclaredFields();
        for (Field f : fields) {
            f.setAccessible(true);
            Type type = f.getGenericType();
            String getName = type.equals(boolean.class) ? toBooleanGetMethod(f
                    .getName()) : "get" + toUpperCaseFirstOne(f.getName());
            String setName = "set"
                    + (type.equals(boolean.class) ? toBooleanSetMethod(f
                            .getName()) : toUpperCaseFirstOne(f.getName()));
            // System.out.println(type + "  " + f.getType() + "==" + setName
            // + "           " + "" + getName);
            Method getMethod;
            Method setMethod;
            Object value = null;
            try {
                setMethod = c.getMethod(setName, f.getType());
                getMethod = c.getMethod(getName);
                value = getMethod.invoke(t, new Object[] {});
                if (type.equals(String.class) || type.equals(int.class)
                        || type.equals(double.class) || type.equals(long.class)
                        || type.equals(boolean.class)
                        || type.equals(byte.class)) {// 基本类型
                    setMethod.invoke(newT, new Object[] { value });
                } else if (f.getType().isInterface()) {// 接口类型，默认为List
                    if (f.getType().getSimpleName().equals("List")) {
                        List<Object> list = (List<Object>) value;
                        List<Object> newList = new ArrayList<Object>();
                        for (Object object : list) {
                            newList.add(clone(object));
                        }
                        setMethod.invoke(newT, new Object[] { newList });
                    } else {
                        Log.e(TAG, "接口解析类型不明确");
                    }
                } else if (type.equals(array.class)) {// 数组
                    int length = Array.getLength(value);
                    Class<?> arr = value.getClass().getComponentType();
                    Object newArr = Array.newInstance(arr, length);
                    System.arraycopy(value, 0, newArr, 0, length);
                    setMethod.invoke(newT, new Object[] { newArr });
                } else if (type.getClass() instanceof Object) {// 自定义对象
                    setMethod.invoke(newT, new Object[] { clone(value) });
                } else {// 不明确对象
                    Log.e(TAG, "数据类型不明确");
                }
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }

        }

        return (T) newT;
    }

    /**
     * 字符串的首字母转化成大写
     * 
     * @param s
     * @return
     */
    private static String toUpperCaseFirstOne(String s) {
        if (Character.isUpperCase(s.charAt(0)))
            return s;
        else
            return (new StringBuilder())
                    .append(Character.toUpperCase(s.charAt(0)))
                    .append(s.substring(1)).toString();
    }

    /**
     * 获取布尔类型的get方法命名
     * 
     * @param s
     * @return
     */
    public static String toBooleanGetMethod(String s) {
        if (s.length() > 2 && s.substring(0, 2).equalsIgnoreCase("is")) {
            return new StringBuilder().append("is")
                    .append(Character.toUpperCase(s.charAt(2)))
                    .append(s.length() == 3 ? "" : s.substring(3)).toString();
        } else
            return new StringBuilder().append("is")
                    .append(Character.toUpperCase(s.charAt(0)))
                    .append(s.length() > 1 ? s.substring(1) : "").toString();

    }

    /**
     * 获取布尔类型的set方法命名
     * 
     * @param s
     * @return
     */
    public static String toBooleanSetMethod(String s) {
        String str = "";
        if (s.length() > 2 && s.substring(0, 2).equalsIgnoreCase("is")) {
            str = new StringBuilder()
                    .append(Character.toUpperCase(s.charAt(2)))
                    .append(s.length() == 3 ? "" : s.substring(3)).toString();
        } else
            str = toUpperCaseFirstOne(s);
        return str;
    }

序列化反序列化克隆

    /**
     * 通过序列化和反序列化 实现克隆（克隆：不同资源物理地址、相同资源内容的对象）
     * 
     * @param t
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T cloneBySerializable(T t) {
        try {
            if (t != null) {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
                oos.writeObject(t);
                oos.close();
                ByteArrayInputStream bais = new ByteArrayInputStream(
                        baos.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bais);
                t = (T) ois.readObject();
                ois.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
            Log.e(TAG, "通过序列化克隆IO异常！");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            Log.e(TAG, "通过序列化克隆未找到数据类型！");
        }

        return t;
    }

实现Cloneable接口

这里，有必要提到的是深浅克隆，白话点说：

  • 浅克隆：也就是只克隆了这个实例，而其子对象是没有克隆的
  • 深克隆：克隆了这个实例以及他的子对象

来个例子（以下是copy的例子，不要告诉别人）：

重点关注下方clone()方法的注释

Company.class

public class Company implements Cloneable{

    private User user;

    private String address;

    public Company(User user, String address) {
        super();
        this.user = user;
        this.address = address;
    }

//省去get set..

    @Override
    protected Object clone() throws CloneNotSupportedException {
    //注意这里，这里实现了子对象user的克隆，这就是所谓的深克隆

        Company company = (Company) super.clone();
    //如果没执行这句，就称之为浅克隆，是不是so easy？
        company.user = (User) company.getUser().clone();
        return company;
    }


}

User.class

public class User implements Cloneable{

    private String username;

    private String password;

    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }


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

THE END

上个工具的完整的代码

package com.stefan.afccutil.mapping;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

import android.R.array;
import android.util.Log;

public class CloneUtil {
    private final static String TAG = CloneUtil.class.getClass()
            .getSimpleName();

    /**
     * 通过方法映射克隆对象
     * 
     * @param t
     *            被克隆对象
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T clone(T t) {
        Class<? extends Object> c = t.getClass();
        Object newT = null;
        try {
            newT = c.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        Field[] fields = c.getDeclaredFields();
        for (Field f : fields) {
            f.setAccessible(true);
            Type type = f.getGenericType();
            String getName = type.equals(boolean.class) ? toBooleanGetMethod(f
                    .getName()) : "get" + toUpperCaseFirstOne(f.getName());
            String setName = "set"
                    + (type.equals(boolean.class) ? toBooleanSetMethod(f
                            .getName()) : toUpperCaseFirstOne(f.getName()));
            // System.out.println(type + "  " + f.getType() + "==" + setName
            // + "           " + "" + getName);
            Method getMethod;
            Method setMethod;
            Object value = null;
            try {
                setMethod = c.getMethod(setName, f.getType());
                getMethod = c.getMethod(getName);
                value = getMethod.invoke(t, new Object[] {});
                if (type.equals(String.class) || type.equals(int.class)
                        || type.equals(double.class) || type.equals(long.class)
                        || type.equals(boolean.class)
                        || type.equals(byte.class)) {// 基本类型
                    setMethod.invoke(newT, new Object[] { value });
                } else if (f.getType().isInterface()) {// 接口类型，默认为List
                    if (f.getType().getSimpleName().equals("List")) {
                        List<Object> list = (List<Object>) value;
                        List<Object> newList = new ArrayList<Object>();
                        for (Object object : list) {
                            newList.add(clone(object));
                        }
                        setMethod.invoke(newT, new Object[] { newList });
                    } else {
                        Log.e(TAG, "接口解析类型不明确");
                    }
                } else if (type.equals(array.class)) {// 数组
                    int length = Array.getLength(value);
                    Class<?> arr = value.getClass().getComponentType();
                    Object newArr = Array.newInstance(arr, length);
                    System.arraycopy(value, 0, newArr, 0, length);
                    setMethod.invoke(newT, new Object[] { newArr });
                } else if (type.getClass() instanceof Object) {// 自定义对象
                    setMethod.invoke(newT, new Object[] { clone(value) });
                } else {// 不明确对象
                    Log.e(TAG, "数据类型不明确");
                }
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }

        }

        return (T) newT;
    }

    /**
     * 字符串的首字母转化成大写
     * 
     * @param s
     * @return
     */
    private static String toUpperCaseFirstOne(String s) {
        if (Character.isUpperCase(s.charAt(0)))
            return s;
        else
            return (new StringBuilder())
                    .append(Character.toUpperCase(s.charAt(0)))
                    .append(s.substring(1)).toString();
    }

    /**
     * 获取布尔类型的get方法命名
     * 
     * @param s
     * @return
     */
    public static String toBooleanGetMethod(String s) {
        if (s.length() > 2 && s.substring(0, 2).equalsIgnoreCase("is")) {
            return new StringBuilder().append("is")
                    .append(Character.toUpperCase(s.charAt(2)))
                    .append(s.length() == 3 ? "" : s.substring(3)).toString();
        } else
            return new StringBuilder().append("is")
                    .append(Character.toUpperCase(s.charAt(0)))
                    .append(s.length() > 1 ? s.substring(1) : "").toString();

    }

    /**
     * 获取布尔类型的set方法命名
     * 
     * @param s
     * @return
     */
    public static String toBooleanSetMethod(String s) {
        String str = "";
        if (s.length() > 2 && s.substring(0, 2).equalsIgnoreCase("is")) {
            str = new StringBuilder()
                    .append(Character.toUpperCase(s.charAt(2)))
                    .append(s.length() == 3 ? "" : s.substring(3)).toString();
        } else
            str = toUpperCaseFirstOne(s);
        return str;
    }

    /**
     * 通过序列化和反序列化 实现克隆（克隆：不同资源物理地址、相同资源内容的对象）
     * 
     * @param t
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T cloneBySerializable(T t) {
        try {
            if (t != null) {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
                oos.writeObject(t);
                oos.close();
                ByteArrayInputStream bais = new ByteArrayInputStream(
                        baos.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bais);
                t = (T) ois.readObject();
                ois.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
            Log.e(TAG, "通过序列化克隆IO异常！");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            Log.e(TAG, "通过序列化克隆未找到数据类型！");
        }

        return t;
    }
}

希望能够帮到你，有错误请及时指出，谢谢

coolgoe
关注
专栏目录
java复制list_Java克隆复制一个新的List集合的方法
weixin_33609486的博客
02-12 2万+
在Java开发中，有时候我们为了源List集合的数据不被修改，如果采用类似“new_list = old_list”这种形式来复制克隆一个新的List集合是绝对不行的，所以我们得采用下面的三种方法来复制一个新的List集合。Java克隆复制ArrayList等List集合的方法一：Java中克隆复制一个List可以在创建List对象时通过将源List集合以参数的形式传入即可，代码如下：import...
Java的对象克隆
lanleihhh的博客
06-13 2370
在浅克隆中：源对象和克隆对象的成员变量指向相同的内存地址 直接重写Object的clone()，会抛出异常 正确用法：1.先实现实现Cloneable接口,再重写clone()方法 测试 作为属性的类(没有重写clone方法) 被克隆的类(重写了clone方法) 测试 两个对象关联的同一个Address对象，Address修改了，克隆对象的信息也发生了变化在深克隆中，无论源对象的成员是基本类型/引用类型，都会复制给克隆对象 也就是在深克隆中，对象和所有成员都会被克隆 而在浅克隆中，只会克隆对象和基本类型成
java中实现对象之间的字段映射方案详解（二）
最新发布
凛鼕将至的博客
04-15 1779
字段映射是指在软件开发过程中，将一个数据结构中的字段映射到另一个数据结构中对应字段的过程。业务场景通常有两种，本系统内部之间数据结构转换和多个系统之间数据交互的数据结构转换。通俗来讲，就是将一个对象中的字段值，赋值给另外一个对象中的字段。本文将跟随《java中实现对象之间的字段映射方案详解（一）》的进度，继续介绍字段映射。希望通过本系列文章的学习，您将能够更好地理解字段映射的内部工作原理，掌握字段映射的使用技巧，以及通过合理的设计完成最佳实践，充分发挥优化字段映射的潜力，为系统的高效运行提供有力保障。
Java克隆复制一个新的List集合的方法
web15285868498的博客
04-19 6152
在Java开发中，有时候我们为了源List集合的数据不被修改，如果采用类似“new_list = old_list”这种形式来复制克隆一个新的List集合是绝对不行的，所以我们得采用下面的三种方法来复制一个新的List集合。 Java克隆复制ArrayList等List集合的方法一： Java中克隆复制一个List可以在创建List对象时通过将源List集合以参数的形式传入即可，代码如下：importjava.util.ArrayList; importjava.util.Arrays; importjav
java List深拷贝的两种方式
北京流年
01-23 6万+
大家都知道java里面分为浅拷贝和深拷贝。举个简单的例子，区分一下浅拷贝和深拷贝的区别 public class Address{ private String address; public Address(String address){ this.address = address; } public String getAdd...
java 对象list 复制_list对象复制问题
weixin_42519772的博客
02-21 1642
Java中的List.addAll复制对象测试代码import java.util.ArrayList;import java.util.List;/*** @author yannis* @date create time：2016年10月31日 上午11:10:31* @version 1.0* @parameter* @since* @return*/public class Demo {...
java对象复制克隆
10-28
标题中的“java对象复制克隆”主要涉及的是深拷贝，这是一种创建一个新对象的方式，新对象不仅复制了原对象的所有属性，还复制了嵌套的对象引用，使得修改复制后的对象不会影响到原始对象。 **浅拷贝**：在浅拷贝中...
深入java对象复制的分析
09-05
Java对象复制是一个重要的概念，它涉及到对象的深拷贝和浅拷贝，以及如何通过不同的方式来实现对象的复制。本文将深入分析Java中的对象复制，主要包括两种常见方法：使用`clone()`方法和通过反射机制。 1. **Object...
java 对象克隆
10-27
总结，Java中的对象克隆是一项重要的功能，用于复制和独立化对象。通过实现`Cloneable`接口和覆盖`clone()`方法，我们可以创建浅克隆对象。对于更复杂的场景，可以自定义克隆逻辑或利用序列化来实现深克隆。理解并...
Java对象的复制三种方式(小结)
08-25
"Java对象的复制三种方式" Java对象的复制是Java编程中的一种常见操作，主要是将一个对象的值复制到另一个对象中，使得两个对象独立，但具有相同的初始值。在实际编程过程中，我们常常需要复制对象，以便于对象之间...
Java克隆list
巫巫巫
09-18 1335
java中，除了基本数据类型和String之外，其他对象的赋值都是传递地址。
java之list对象拷贝
百里川字登风
05-12 6940
springboot项目中经常会使用对象拷贝, 比如DTO转entity, entity转VO返回前端 单个对象常用的工具类有很多, 比如 #hutool cn.hutool.core.bean.BeanUtil #spring自带 org.springframework.beans.BeanUtils 开发过程中经常遇到的list对象拷贝时, 可能有些同学会循环去处理 List<UserDTO> userList; List<UserEntity> resultList = .
java 克隆对象 list_Java 对象与集合的克隆 (Clone) 实用类
weixin_28871989的博客
02-12 678
摘自某位网友的开源类库，应该某些场景需要用到，Mark 一下import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;imp...
java复制list对象，问题和解决方式
u011506884的博客
04-11 2289
java复制list对象，问题和解决方式
Java List的深度克隆
weixin_30881367的博客
10-08 1691
关于java List的深度克隆 List是java容器中最常用的顺序存储数据结构之一。有些时候我们将一组数据取出放到一个List对象中，但是可能会很多处程序要读取他或者是修改他。尤其是并发处理的话，显然有的时候有一组数据有的时候是不够用的。这个时候我们通常会复制出一个甚至多个克隆List来执行更多的操作。 常见的List的克隆方式有很多，下面我们来列举几种常见的List复制的方式： （首先...
java中copy 一个list集合的方法
weixin_34337381的博客
03-19 2516
java将一个list里的数据转移到另外一个list，可以使用for语句，一次使用add方法，示例如下： ArrayList list1=new ArrayList(); list1.add("1"); list1.add("2"); list1.add("3"); ArrayList list2=new ArrayList(); list2...
Java复制List集合
蔡双敏的博客
01-12 2万+
JDK貌似没有自带的复制List集合的方法，因此，复制方法需要自己去实现。下面介绍两种简单实用的复制List集合的方法。 方法1、创建新的ArrayList集合时复制 public static void main(String[] args) {     List list = new ArrayList();     list.add("1");     list.add("2")
java List复制：浅拷贝与深拷贝
热门推荐
DeMonnnnnn
01-16 11万+
List浅拷贝众所周知，list本质上是数组，而数组的是以地址的形式进行存储。 如上图将list A浅拷贝给list B，由于进行的是浅拷贝，所以直接将A的内容复制给了B，java中相同内容的数组指向同一地址，即进行浅拷贝后A与B指向同一地址。造成的后果就是，改变B的同时也会改变A，因为改变B就是改变B所指向地址的内容，由于A也指向同一地址，所以A与B一起改变。 几种浅拷贝1、遍历循环复制List<
java深度克隆工具类——支持对象和对象集合
toBeMN的博客
12-19 1万+
正经学徒，佛系记录，不搞事情 第一步：创建工具类 直接使用commons-beanutils实现对象拷贝，引入pom &lt;dependency&gt; &lt;groupId&gt;commons-beanutils&lt;/groupId&gt; &lt;artifactId&gt;commons-beanutils&lt;/artifactId&gt; &lt;version...
Java对象克隆深度解析
"Java对象的克隆技术是Java编程中的一种重要概念，它涉及到对象的复制和独立性。本文将深入探讨如何在Java中实现对象的克隆，以及何时需要使用这种技术。" 在Java中，对象的克隆允许我们创建一个已有对象的副本，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值