精华内容
下载资源
问答
  • 对象属性值的复制工具类 1.全复制 2.部分复制 3.部分不复制
  • Java copy对象工具类

    2018-07-27 13:47:52
    Java CopyUtil工具类,可以进行对象的深copy,比如:对象里面包含对象对象里面包含Map,List,Set...等复杂类型的属性都可以copy,copy后的对象与原有对象没有联系,即改变原有对象内容,不会改变copy后的对象里面的...
  • Java BeanUtils对象复制工具类及方法

    千次阅读 2018-12-14 17:02:37
    1. BeanUtils.copyProperties(Object source, Object target...用法: 讲source的属性值复制到target,属性为null时也会进行复制。 需求:排除null值进行复制 public class CopyObjectUtil { public static String...

    1. BeanUtils.copyProperties(Object source, Object target)

    用法: 讲source的属性值复制到target,属性为null时也会进行复制。

    需求:排除null值进行复制
    public class CopyObjectUtil {
    
    
        public static String[] getNullPropertyNames(Object source) {
            final BeanWrapper src = new BeanWrapperImpl(source);
            java.beans.PropertyDescriptor[] pds = src.getPropertyDescriptors();
    
            Set<String> emptyNames = new HashSet<String>();
            for (java.beans.PropertyDescriptor pd : pds) {
                Object srcValue = src.getPropertyValue(pd.getName());
                if (srcValue == null) emptyNames.add(pd.getName());
            }
            String[] result = new String[emptyNames.size()];
            return emptyNames.toArray(result);
        }
    
        public static void copyPropertiesIgnoreNull(Object src, Object target) {
            BeanUtils.copyProperties(src, target, getNullPropertyNames(src));
        }
    
    
    }
    

    使用方式与BeanUtils.copyProperties相同:

    CopyObjectUtil.copyPropertiesIgnoreNull(Object source, Object target);

    2. BeanUtils.copyProperties(Object source, Object target, new String[] { "id", "createDate", "modifyDate" })

    用法:排除指定字段进行复制

    展开全文
  • java对象复制和属性值复制工具类

    千次阅读 2017-11-30 16:19:10
    两个不同类型的对象中有字段名称不区分大小写的情况下一样,字段含义一样,需要组装到另一个对象中去,然后就写了一个这种工具类 我的类型比较特殊,老系统和新系统的对象命名大小写命名不一致,并且字段相同类型也...

    两个不同类型的对象中有字段名称不区分大小写的情况下一样,字段含义一样,需要组装到另一个对象中去,然后就写了一个这种工具类
    我的类型比较特殊,老系统和新系统的对象命名大小写命名不一致,并且字段相同类型也有不一致的情况,所以自己写了一个,
    不是很完美基本能用。

    温馨提示:
    如果同一种类型的对象 属性字段名equals相等 并且类型一致。则完全可以用commons-beanutils包或者spring包中
    的BeanUtils工具类中的copey属性方法。

    /**
     * 实体类字段值相同的复制
     *
     * @author 隔壁老王 2017年8月18日
     */
    public class CopyBeanUtil {
        static Logger log = LoggerFactory.getLogger(CopyBeanUtil.class);
    
        /**
         * 复制sour里属性不为空的值到obje为空的属性
         *
         * @param obje    目标实体类
         * @param sour    源实体类
         * @param isCover 是否保留obje类里不为null的属性值(true为保留源值,属性为null则赋值)
         * @return obje
         */
        public static Object Copy(Object obje, Object sour, boolean isCover) {
            Field[] fields = sour.getClass().getDeclaredFields();
            for (int i = 0, j = fields.length; i < j; i++) {
                String propertyName = fields[i].getName();
                Object propertyValue = getProperty(sour, propertyName);
                if (isCover) {
                    if (getProperty(obje, propertyName) == null && propertyValue != null) {
                        Object setProperty = setProperty(obje, propertyName, propertyValue);
                    }
                } else {
                    Object setProperty = setProperty(obje, propertyName, propertyValue);
                }
    
            }
            return obje;
        }
    
        /**
         * 复制sour里属性不为空的值到obj里并相加
         *
         * @param obj     目标实体类
         * @param sour    源实体类
         * @param isCover
         * @return obj
         */
        public static Object CopyAndAdd(Object obj, Object sour, boolean isCover) {
            Field[] fields = sour.getClass().getDeclaredFields();
            for (int i = 0, j = fields.length; i < j; i++) {
                String propertyName = fields[i].getName();
                Object sourPropertyValue = getProperty(sour, propertyName);
                Object objPropertyValue = getProperty(obj, propertyName);
                if (isCover) {
                    if (objPropertyValue == null && sourPropertyValue != null) {
                        Object setProperty = setProperty(obj, propertyName, sourPropertyValue);
                    } else if (objPropertyValue != null && sourPropertyValue == null) {
                        Object setProperty = setProperty(obj, propertyName, objPropertyValue);
                    } else if (objPropertyValue != null && sourPropertyValue != null) {
                        Object setProperty = setProperty(obj, propertyName, ((int) sourPropertyValue) + (int) objPropertyValue);
                    }
                }
    
            }
            return obj;
        }
    
    
        /**
         * 得到值
         *
         * @param bean
         * @param propertyName
         * @return
         */
        private static Object getProperty(Object bean, String propertyName) {
            Class clazz = bean.getClass();
            try {
                Field field = clazz.getDeclaredField(propertyName);
                Method method = clazz.getDeclaredMethod(getGetterName(field.getName(),field.getType()), new Class[]{});
                return method.invoke(bean, new Object[]{});
            } catch (Exception e) {
            }
            return null;
        }
    
        /**
         * 给bean赋值
         *
         * @param bean
         * @param propertyName
         * @param value
         * @return
         */
        private static Object setProperty(Object bean, String propertyName, Object value) {
            Class clazz = bean.getClass();
            try {
                Field field = clazz.getDeclaredField(propertyName);
                Method method = clazz.getDeclaredMethod(getSetterName(field.getName()), new Class[]{field.getType()});
                return method.invoke(bean, new Object[]{value});
            } catch (Exception e) {
            }
            return null;
        }
    
        /**
         * 根据变量名得到get方法
         *
         * @param propertyName
         * @return
         */
        private static String getGetterName(String propertyName) {
            String method ;
            if( propertyName.length()>1&& Character.isUpperCase(propertyName.charAt(1))){
                 method = "get" +propertyName;
            }else{
                method = "get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            }
            return method;
        }
    
        /**
         * 根据变量名和类型获取getter方法
         * @param propertyName
         * @param type
         * @return
         */
        private static String getGetterName(String propertyName, Class<?> type) {
            String method ;
            if(type==Boolean.class|| type==boolean.class){
                if("is".equalsIgnoreCase(propertyName.substring(0, 2))){
                    return propertyName;
                }else{
                    return "is" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
                }
    
            }
            if( propertyName.length()>1&& Character.isUpperCase(propertyName.charAt(1))){
                method = "get" +propertyName;
            }else{
                method = "get" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            }
            return method;
        }
    
        /**
         * 得到setter方法
         *
         * @param propertyName 变量名
         * @return
         */
        private static String getSetterName(String propertyName) {
    //        String method = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            String method ;
            if( propertyName.length()>1&& Character.isUpperCase(propertyName.charAt(1))){
                method = "set" +propertyName;
            }else{
                method = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
            }
            return method;
        }
    
    
        /**
         * 父类集合转成子类集合集合通用方法(子类集合接收父类集合)
         *
         * @param list 父类集合
         * @param <T>  子类
         * @param <E>  父类
         * @return
         */
        public static <T, E> List<T> chang2ChildClassList(List<E> list) {
            List<T> alist = new ArrayList<>();
            for (E o : list) {
                alist.add((T) o);
            }
            return alist;
    
        }
    
        /**
         * 属性copy  复制sour里属性和obje里属性值忽略大小写相同的 ,不为空的值赋值到obje里
         * 如果存在属性复杂类型并为有效值慎用或改进
         *
         * @param obje
         * @param sour
         * @param isCover 是否保留obje里面属性值不为空的字段值
         * @return
         */
        public static Object copyByIgnoreCase(Object obje, Object sour, boolean isCover) {
    
            try {
                Field[] objFields = obje.getClass().getDeclaredFields();
    
                Field[] sourFields = sour.getClass().getDeclaredFields();
                for (int i = 0; i < sourFields.length; i++) {
                    String sourPropertyName = sourFields[i].getName();
                    //获取来源对象的属性值
                    Object propertyValue = getSourPropertyValue(sour, sourPropertyName);
                    for (int j = 0; j < objFields.length; j++) {
    
                        try {
                            String objPropertyName = objFields[j].getName();
                            if (objPropertyName.equalsIgnoreCase(sourPropertyName)) {
                                if (isCover) {
                                    if (getProperty(obje, objPropertyName) == null && propertyValue != null) {
                                        setObjProperty(obje, objPropertyName, propertyValue);
                                    }
                                } else {
                                    setObjProperty(obje, objPropertyName, propertyValue);
                                }
                                break;
                            }
                        } catch (Exception e) {
                            log.error("给目标bean赋值出错,objPropertyName:{},value:{}",sourPropertyName,propertyValue,e);
                            e.printStackTrace();
                        }
                    }
    
                }
            } catch (SecurityException e) {
                e.printStackTrace();
                log.error("给目标bean赋值出错,obje:{},sour:{}", JSON.toJSONString(obje), JSON.toJSONString(sour),e);
            }
            return obje;
        }
    
        /**
         * 根据属性名获取的值
         *
         * @param sourceBean
         * @param sourcePropertyName
         * @return
         */
        private static Object getSourPropertyValue(Object sourceBean, String sourcePropertyName) {
            Class clazz = sourceBean.getClass();
            try {
                Field field = clazz.getDeclaredField(sourcePropertyName);
                Method method = clazz.getDeclaredMethod(getGetterName(field.getName(),field.getType()), new Class[]{});
                return method.invoke(sourceBean, new Object[]{});
            } catch (Exception e) {
                log.error("获取属性名(不区分大小写)相似的值赋值出差", e);
            }
            return null;
        }
    
    
    
        /**
         * 给目标bean赋值
         *
         * @param objBean
         * @param sourcePropertyName
         * @param value
         * @return
         */
        private static Object setObjPropertyBySourceProperty(Object objBean, String sourcePropertyName, Object value) {
            Class clazz = objBean.getClass();
            Field[] fields = clazz.getDeclaredFields();
            try {
                for (int i = 0, j = fields.length; i < j; i++) {
                    String propertyName = fields[i].getName();
                    if (sourcePropertyName.equalsIgnoreCase(propertyName)) {
                        Field field = clazz.getDeclaredField(propertyName);
                        if (field.getType() == BigDecimal.class) {
                            if (value instanceof String) {
                                value = new BigDecimal(String.valueOf(value));
                            } else if (value instanceof Integer || value instanceof Double) {
    //							传double直接new BigDecimal,数会变大
                                value = BigDecimal.valueOf(Double.parseDouble(String.valueOf(value)));
                            }
                        }
                        if (field.getType() == Double.class || field.getType() == double.class) {
                            if (value instanceof BigDecimal) {
                                DecimalFormat df = new DecimalFormat("#.000000");
                                Double v = Double.parseDouble(String.valueOf(value));
                                value = df.format(v);
                            }
                        }
    
                        Method method = clazz.getDeclaredMethod(getSetterName(field.getName()), new Class[]{field.getType()});
                        return method.invoke(objBean, new Object[]{value});
                    }
                }
    
            } catch (Exception e) {
            }
            return null;
        }
    
    
        /**
         * 给目标bean赋值
         *
         * @param objBean
         * @param propertyName
         * @param value
         * @return
         */
        private static Object setObjProperty(Object objBean, String propertyName, Object value) {
            Class clazz = objBean.getClass();
            try {
                Field field = clazz.getDeclaredField(propertyName);
                if (field.getType() == BigDecimal.class) {
                    if (value instanceof String) {
                        value = new BigDecimal(String.valueOf(value));
                    } else if (value instanceof Integer || value instanceof Double) {
    //							传double直接new BigDecimal,数会变大
                        value = BigDecimal.valueOf(Double.parseDouble(String.valueOf(value)));
                    }
                }
                if (field.getType() == Double.class || field.getType() == double.class) {
                    if (value instanceof BigDecimal) {
                        DecimalFormat df = new DecimalFormat("#.000000");
                        Double v = Double.parseDouble(String.valueOf(value));
                        value =new BigDecimal(df.format(v));
                    }
                }
                if (field.getType() == Integer.class || field.getType() == int.class) {
                    if (value instanceof Float) {
                         value = Math.round(Float.parseFloat(String.valueOf(value)));
                    }
                }
                Method method = clazz.getDeclaredMethod(getSetterName(field.getName()), new Class[]{field.getType()});
                log.info("给目标bean赋值,propertyName:{},value:{}",propertyName,value);
                Object obj = method.invoke(objBean, new Object[]{value});
                return obj;
    
            } catch (Exception e) {
                log.error("给目标bean赋值出错,propertyName:{},value:{}",propertyName,value,e);
            }
            return null;
        }
        public static void main(String[] args) {
    //        ReAlarmResult re= new ReAlarmResult();
    //        re.setAlarmContent("sdfsdfsd");
    //        re.setBlat(2.234343);
    //        re.setBlon(34.34324);
    //        ReAlarmResult s = new ReAlarmResult();
    //        s.setAlarmContent("222");
    //        copyByIgnoreCase(s,re,true);
    //        System.out.printf(JSON.toJSONString(s));
    //        BeanUtils.copyProperties();
            //BeanUtils.copyProperties();
        }
    
    }
    
    展开全文
  • Java复制对象与集合工具类

    千次阅读 2019-03-31 19:13:04
    项目中经常需要将某个对象的...利用spring提供的BeanUtils,自己简单封装了一个工具类。 public class CopyUtils { /** * 复制集合 */ public static <T,K> List<T> copyList(List<K> sou...

    项目中经常需要将某个对象的属性值复制给另一个对象,或者将一个集合复制到另一个集合。利用spring提供的BeanUtils,自己简单封装了一个工具类。

    public class CopyUtils {
    
        /**
         * 复制集合
         */
        public static <T,K> List<T> copyList(List<K> sourceList, Class<T> clazz) {
            if (CollectionUtils.isEmpty(sourceList)) {
                return null;
            }
    
            ArrayList<T> target = new ArrayList<>();
            sourceList.forEach(k -> target.add(convert(k, clazz)));
            return target;
        }
    
        /**
         * 复制对象
         */
        public static <T,K> T convert(K source, Class<T> clazz) {
            T t = BeanUtils.instantiate(clazz);
            BeanUtils.copyProperties(source, t);
            return t;
        }
    
    }
    
    展开全文
  • 本号主要是Java常用关键技术点,通用工具类的分享;以及springboot+springcloud+Mybatisplus+druid+mysql+redis+swagger+maven+docker等集成框架的技术分享;datax、kafka、flink等大数据处理框架的技术分享。文章会...

    介绍语

    本号主要是Java常用关键技术点,通用工具类的分享;以及springboot+springcloud+Mybatisplus+druid+mysql+redis+swagger+maven+docker等集成框架的技术分享;datax、kafka、flink等大数据处理框架的技术分享。文章会不断更新,欢迎码友关注点赞收藏转发!

    望各位码友点击关注,冲1000粉。后面会录制一些视频教程,图文和视频结合,比如:图书介绍网站系统、抢购系统、大数据中台系统等。技术才是程序猿的最爱,码友们冲啊

    如果码友觉得代码太长,可以从头到尾快速扫射一遍,了解大概即可。觉得有用后再转发收藏,以备不时之需。

    正文:

    对象复制工具类,简单好用。但是使用场景好像不多,先收藏

    例子1

    复制学生类到另一个学生类

    import java.time.LocalDate;
     ​
     public class BeanUtilTest {
         public static void main(String[] args) {
             Student student = new Student("zhang三",
                     12, "花果山", LocalDate.of(1990, 2, 26));
             Student studentCopy = new Student();
             BeanCopyUtil.merge(student, studentCopy);
     ​
             System.out.println(studentCopy);
         }
     }
     ​
     // 控制台打印
     Student(name=zhang三, age=12, address=花果山, birthday=1990-02-26)

    例子用到的实体类

    import lombok.AllArgsConstructor;
     import lombok.Data;
     import lombok.NoArgsConstructor;
     ​
     import java.time.LocalDate;
     ​
     @Data
     @AllArgsConstructor
     @NoArgsConstructor
     public class Student {
         private String name;
         private int age;
         private String address;
         private LocalDate birthday;
     }

    工具类源码:

    import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     ​
     import java.lang.reflect.Field;
     ​
     /**
      * 对象赋值工具类
      *
      * @author liangxn
      */
     public class BeanCopyUtil {
     ​
         private static final Logger logger = LoggerFactory.getLogger(BeanCopyUtil.class);
     ​
         /**
          * 相同对象合并,将原对象的非空属性的值赋值给目标对象
          *
          * @param origin      源对象
          * @param destination 目标对象
          * @param <T>         对象的类型
          */
         public static <T> void merge(T origin, T destination) {
             if (origin == null || destination == null) {
                 return;
             }
             if (!origin.getClass().equals(destination.getClass())) {
                 return;
             }
     ​
             Field[] fields = origin.getClass().getDeclaredFields();
             for (Field field : fields) {
                 field.setAccessible(true);
                 try {
                     Object value = field.get(origin);
                     if (null != value) {
                         field.set(destination, value);
                     }
                 } catch (IllegalAccessException e) {
                     logger.error("访问对象异常", e);
                 }
                 field.setAccessible(false);
             }
         }
     }

    鄙人编码十年多,在项目中也积累了一些工具类,很多工具类在每个项目都有在用,很实用。大部分是鄙人封装的,有些工具类是同事封装的,有些工具类已经不记得是ctrl+c的还是自己封装的了,现在有空就会总结项目中大部分的工具类,分享给各位码友。如果文章中涉及的代码有侵权行为请通知鄙人处理。

    计划是先把工具类整理出来,正所谓工欲善其事,必先利其器。项目中不管是普通单体项目还是多模块maven项目或是分布式微服务,一部分功能模块都是可以重用的,工具类模块就是其中之一。

    展开全文
  • JAVA复制对象和集合的工具类 因为BeanUtils.copyProperties(Object source, Object target),只能复制对象,不能复制数组和集合,所以决定写个工具类来解决 public class CopyUtils { /** * 复制对象 */ public ...
  • 项目简介 beanmapping 用于 java 对象属性赋值 项目中经常需要将一个对象的属性赋值到另一个对象中 常见的工具有很多但都多少不够简洁要么不够强大 特性 支持对象属性的浅拷贝 支持不同名称字段的指定赋值 支持...
  • java反射机制创建对象实现:java 深度拷贝 -超完美,只使反射机制,不使用其它封装好的深度拷贝的工具类
  • java 对象拷贝工具类

    千次阅读 2020-02-22 17:03:07
    import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; public class ObjectCopy { ... * 复制对象值 不复制对象地址 * * @param src * @param dest */ public ...
  • java 对象复制 集合复制工具类

    千次阅读 2019-09-29 10:44:52
    * 将源POJO对象数据复制给目标POJO对象的同名属性 * * @date 2018年12月4日 * @version 1.0 * * @param source 源 * @param target 目标 * @param * @param * @return 目标 */ public static , T> T ...
  • 第一步:创建工具类 直接使用commons-beanutils实现对象拷贝,引入pom &lt;dependency&gt; &lt;groupId&gt;commons-beanutils&lt;/groupId&gt; &lt;artifactId&gt;commons-...
  • 文章目录开头聊几句Java属性拷贝工具类使用总结字段和属性使用说明**org.springframework.beans.BeanUtils#copyProperties**org.apache.commons.beanutils.PropertyUtils#_copyProperties_org.apache.commons....
  • java实体转map工具类

    2015-04-14 16:42:51
    java实体转换为map mybatis里用map更方便
  • Java复制Bean,List工具类

    2020-08-06 09:59:28
    * 复制对象 * * @param source 源 要复制的对象 * @param target 目标 复制到此对象 * @param <T> * @return */ public static <T> T copy(Object source, Class<T> target) { try {
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • Java二进制IO与文件复制操作实例 16个目标文件 内容索引:Java源码,初学实例,二进制,文件复制 Java二进制IO与文件复制操作实例,好像是一本书的例子,源代码有的是独立运行的,与同目录下的其它代码文件互不联系...
  • Java Bean 属性复制的几种库工具类

    千次阅读 2019-04-25 22:41:41
    为此业界有很多开源的解决方案,列出一些常见的如下: Apache org.apache.commons.beanutils.PropertyUtils.copyProperties Apache org.apache.commons.beanutils.BeanUtils.copyProperties Spring org.spring...
  • Java中分为深拷贝和浅拷贝; BeanA 对象如下: public class BeanA { private String str1, str2; private List<BeanB> beanBList; } 如需浅拷贝,则需实现Serializable 接口,并重写 clone 方法,...
  • package main.java.java02.IO.fuzhi; import java.io.*; /** * @author:Mr.wang * @date:2019/2/21 0021 上午 10:32 ... //文件夹拷贝 不管是路径还是File对象都可直接使用 //拷贝文件夹方法 // Stri...
  • java复制对象的几种方法

    千次阅读 2020-04-11 15:50:42
    最近业务要复制对象,但我又不想一个个的去get、set,于是就网上找了三种复制对象的方法。 一,浅层复制。 1.需要复制的实现Cloneable接口; 2.复写clone()方法; import java.lang.Cloneable;; public class ...
  • Java知识体系最强总结(2021版)

    万次阅读 多人点赞 2019-12-18 10:09:56
    本人从事Java开发已多年,平时有记录问题解决方案和总结知识点的习惯,整理了一些有关Java的知识体系,这不是最终版,会不定期的更新。也算是记录自己在从事编程工作的成长足迹,通过博客可以促进博主与阅读者的共同...
  • 功能强大的文件拷贝工具类复制文件  @author:heyuelin 2011-01-06  @param srcFile 源文件File  @param destDir 目标目录File  @param isClone true:将按照源文件目录拷贝,false:将提取出文件拷贝到...
  • JAVA对象任意深度克隆clone工具类分享 源代码下载地址:http://www.zuidaima.com/share/1550463408114688.htm
  • import java.lang.reflect.Field; /** * @Author: yl * @Despriction: javaBean的工具类 * @Package: com.elane.utils * @Date:Created in 2019/5/11 15:42 * @Modify By: */ public ...
  • Java Utils工具类大全

    万次阅读 2019-01-21 23:06:10
    另外希望身为Java牛牛的你们一起测试和完善,欢迎入群263641914 一起封装和完成常用的Java代码。 节约撸码时间以方便有更多的时间去把妹子~ #开发环境 Win7x64 JDK1.7 IDEA14 #项目结构 │ README.m...
  • java 复制非空对象属性值

    千次阅读 2017-02-15 11:31:27
    用于对象拷贝,spring 和 Apache都提供了相应的工具类方法,BeanUtils.copyProperties 但是对于非空属性拷贝就需要自己处理了 在这里借用spring中org.springframework.beans.BeanUtils类提供的方
  • Java 对象copy之BeanCopier工具类的使用

    万次阅读 2018-11-23 15:20:01
    业务系统中经常需要两个对象进行属性的拷贝,不能否认逐个的对象拷贝是最快速最安全的做法,但是当数据对象的属性字段数量超过程序员的容忍的程度,代码因此变得臃肿不堪,使用一些方便的对象拷贝工具类将是很好的...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,...JDK:Java Development Kit 的简称,java 开发工具包,提供了 java 的开发环境和运行环境。 JRE:Java Runtime Environ...
  • JAVA常用工具类汇总

    万次阅读 多人点赞 2019-08-06 16:05:46
    一、字符串工具类 org.apache.commons.lang.StringUtils pom文件: <!-- https://mvnrepository.com/artifact/org.apache.commons/org.apache.commons.lang --> <dependency> <groupId>org.apache...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 143,629
精华内容 57,451
关键字:

java复制对象工具类

java 订阅