精华内容
下载资源
问答
  • 2019-03-31 19:13:04

    项目中经常需要将某个对象的属性值复制给另一个对象,或者将一个集合复制到另一个集合。利用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 copy对象工具类

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

    千次阅读 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文件操作工具类,类实现了复制文件和文件合并的功能,需要的朋友可以参考下
  • 对象属性值的复制工具类 1.全复制 2.部分复制 3.部分不复制
  • java反射机制创建对象实现:java 深度拷贝 -超完美,只使反射机制,不使用其它封装好的深度拷贝的工具类
  • Java对象映射工具类封装

    千次阅读 2021-11-18 14:11:34
    文章主要记录一下工作中封装的对象转换工具类 /** * Spring的BeanUtils只能映射类型相同的属性,无法满足将Date转字符串,枚举类型转换等需求 * 所以将Spring的BeanUtils源码复制出来,自己扩展了映射逻辑 */ ...

    文章主要记录一下工作中封装的对象转换工具类

    /**
     * Spring的BeanUtils只能映射类型相同的属性,无法满足将Date转字符串,枚举类型转换等需求
     * 所以将Spring的BeanUtils源码复制出来,自己扩展了映射逻辑
     */
    public class BeanMapUtil {
        /**
         * 缓存字段上使用DateFormat注解配置的日期格式,key为包名+类名+字段名,value为使用DateFormat注解配置的日期格式
         */
        private static final Map<String, String> DATE_FORMAT_CACHE = new ConcurrentHashMap<>();
        private static final Logger LOGGER = LoggerFactory.getLogger(BeanMapUtil.class);
    
        private BeanMapUtil() {
        }
    
        /**
         * <p>将集合转换成其他类型的集合,并将每个元素的属性根据名称拷贝到新集合的元素中。如果遇到属性类型不一致,会自动根据类型进行转换</p>
         * <p>通常用于将pojo转成VO</p>
         * <p>在转换时,如果字段同名但类型不一致,还支持日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串、yyyy-MM-dd HH:mm:ss格式的字符串字段转成日期类型,将枚举代码转换为枚举类型、将所有基本数据类型自动转为字符串类型功能</p>
         *
         * @param originalList 原始的集合
         * @param resultType   新集合元素的类对象
         * @param <T>          新集合元素的类型
         * @return 新集合
         */
        @SuppressWarnings("unchecked")
        public static <T> List<T> convertList(List<?> originalList, Class<T> resultType) {
            return convertList(originalList, resultType, (String[]) null);
        }
    
        /**
         * <p>将集合转换成其他类型的集合,并将每个元素的属性根据名称拷贝到新集合的元素中。如果遇到属性类型不一致,会自动根据类型进行转换</p>
         * <p>通常用于将pojo转成VO</p>
         * <p>在转换时,如果字段同名但类型不一致,还支持日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串、yyyy-MM-dd HH:mm:ss格式的字符串字段转成日期类型,将枚举代码转换为枚举类型、将所有基本数据类型自动转为字符串类型功能</p>
         *
         * @param originalList     原始的集合
         * @param resultType       新集合元素的类对象
         * @param ignoreProperties array of property names to ignore
         * @param <T>              新集合元素的类型
         * @return 新集合
         */
        @SuppressWarnings("unchecked")
        public static <T> List<T> convertList(List<?> originalList, Class<T> resultType,
                                              @Nullable String... ignoreProperties) {
            if (CollectionUtils.isEmpty(originalList)) {
                return Lists.newArrayList();
            }
    
            // 类型相同,直接返回,不再通过反射复制属性
            if (resultType.isAssignableFrom(originalList.get(0).getClass())) {
                return (List<T>) originalList;
            }
    
            // 将集合转换成其他类型的集合,并将每个元素的属性根据名称拷贝到新集合的元素中
            List<T> result = new ArrayList<>(originalList.size());
            for (Object o : originalList) {
                T newObject = BeanUtils.instantiateClass(resultType);
                copyProperties(o, newObject, ignoreProperties);
                result.add(newObject);
            }
            return result;
        }
    
        /**
         * 将对象转换成其他类型的对象,并将属性根据名称拷贝到新对象。如果遇到属性类型不一致,会自动根据类型进行转换
         * 在转换时,如果字段同名但类型不一致,还支持日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串、yyyy-MM-dd HH:mm:ss格式的字符串字段转成日期类型,将枚举代码转换为枚举类型、将所有基本数据类型自动转为字符串类型功能
         *
         * @param source     原始对象
         * @param resultType 目标类型的类对象
         * @param <T>        目标类型
         * @return 新对象
         */
        @SuppressWarnings("unchecked")
        public static <T> T convertObject(Object source, Class<T> resultType) {
            return convertObject(source, resultType, (String[]) null);
        }
    
        /**
         * 将对象转换成其他类型的对象,并将属性根据名称拷贝到新对象。如果遇到属性类型不一致,会自动根据类型进行转换
         * 在转换时,如果字段同名但类型不一致,还支持日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串、yyyy-MM-dd HH:mm:ss格式的字符串字段转成日期类型,将枚举代码转换为枚举类型、将所有基本数据类型自动转为字符串类型功能
         *
         * @param source           原始对象
         * @param resultType       目标类型的类对象
         * @param ignoreProperties array of property names to ignore
         * @param <T>              目标类型
         * @return 新对象
         */
        @SuppressWarnings("unchecked")
        public static <T> T convertObject(Object source, Class<T> resultType,
                                          @Nullable String... ignoreProperties) {
            if (source == null) {
                return null;
            }
    
            // 类型相同,直接返回,不再通过反射复制属性
            if (resultType.isAssignableFrom(source.getClass())) {
                return (T) source;
            }
    
            // 转换类型
            T result = BeanUtils.instantiateClass(resultType);
            copyProperties(source, result, ignoreProperties);
            return result;
        }
    
        /**
         * Copy the property values of the given source bean into the target bean.
         * <p>Note: The source and target classes do not have to match or even be derived
         * from each other, as long as the properties match. Any bean properties that the
         * source bean exposes but the target bean does not will silently be ignored.
         * <p>This is just a convenience method. For more complex transfer needs,
         * consider using a full BeanWrapper.
         *
         * @param source the source bean
         * @param target the target bean
         * @see BeanWrapper
         */
        public static void copyProperties(Object source, Object target) {
            copyProperties(source, target, (String[]) null);
        }
    
        /**
         * 将Map转成javabean
         *
         * @param map       map
         * @param beanClass 目标类型的类对象
         * @param <T>       目标类型
         * @return javabean
         */
        public static <T> T mapToObject(Map<String, Object> map, Class<T> beanClass) {
            if (map == null) {
                return null;
            }
    
            T obj;
            try {
                obj = beanClass.newInstance();
    
                BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
                PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
                for (PropertyDescriptor property : propertyDescriptors) {
                    Method setter = property.getWriteMethod();
                    if (setter != null) {
                        setter.invoke(obj, map.get(property.getName()));
                    }
                }
            } catch (IllegalAccessException | IntrospectionException | InstantiationException | InvocationTargetException e) {
                throw new IllegalStateException(
                        "Could not transform " + map + " to " + beanClass.getName(), e);
            }
    
            return obj;
        }
    
        /**
         * 将javabean转成Map
         *
         * @param obj javabean
         * @return 转换结果
         */
        @SuppressWarnings("unchecked")
        public static Map<String, Object> objectToMap(Object obj) {
            if (obj == null) {
                return null;
            } else if (obj instanceof Map) {
                return (Map<String, Object>) obj;
            }
    
            Map<String, Object> map = new HashMap<>(32);
    
            try {
                BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
                PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
                for (PropertyDescriptor property : propertyDescriptors) {
                    String key = property.getName();
                    if (key.compareToIgnoreCase("class") == 0) {
                        continue;
                    }
                    Method getter = property.getReadMethod();
                    Object value = getter != null ? getter.invoke(obj) : null;
                    map.put(key, value);
                }
            } catch (IllegalAccessException | IntrospectionException | InvocationTargetException e) {
                throw new IllegalStateException(
                        "Could not transform " + JSON.toJSONString(obj) + " to map", e);
            }
    
            return map;
        }
    
        /**
         * Copy the property values of the given source bean into the given target bean.
         * <p>Note: The source and target classes do not have to match or even be derived
         * from each other, as long as the properties match. Any bean properties that the
         * source bean exposes but the target bean does not will silently be ignored.
         *
         * @param source           the source bean
         * @param target           the target bean
         * @param ignoreProperties array of property names to ignore
         * @see BeanWrapper
         */
        public static void copyProperties(Object source, Object target,
                                          @Nullable String... ignoreProperties) {
    
            Assert.notNull(source, "Source must not be null");
            Assert.notNull(target, "Target must not be null");
    
            Class<?> targetClass = target.getClass();
            PropertyDescriptor[] targetPds = BeanUtils.getPropertyDescriptors(targetClass);
            List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);
    
            for (PropertyDescriptor targetPd : targetPds) {
                Method writeMethod = targetPd.getWriteMethod();
                if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
                    PropertyDescriptor sourcePd = BeanUtils.getPropertyDescriptor(source.getClass(), targetPd.getName());
                    if (sourcePd != null) {
                        Method readMethod = sourcePd.getReadMethod();
                        if (readMethod != null) {
                            try {
                                if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
                                    readMethod.setAccessible(true);
                                }
                                Object sourceValue = readMethod.invoke(source);
                                if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                                    writeMethod.setAccessible(true);
                                }
                                if (sourceValue != null) {
                                    Object targetValue = getTargetValue(targetPd, sourceValue, targetClass);
                                    if (targetValue != null) {
                                        writeMethod.invoke(target, targetValue);
                                    }
                                }
                            } catch (Exception ex) {
                                throw new IllegalStateException(
                                        "Could not copy property '" + targetPd.getName() + "' from source to target", ex);
                            }
                        }
                    }
                }
            }
        }
    
        /**
         * 当源属性类型和目标属性类型不同时,进行一些内置的转换
         */
        @SuppressWarnings("unchecked")
        private static Object getTargetValue(PropertyDescriptor targetPd, Object sourceValue, Class<?> targetClass) throws ParseException {
            Object targetValue = sourceValue;
            Class<?> targetPropertyType = targetPd.getPropertyType();
            Class<?> sourcePropertyType = sourceValue.getClass();
            // 拷贝属性时如果源类型和目标类型不一致,如果是预定义好的可转换的情况,进行内置转换
            if (!targetPropertyType.isAssignableFrom(sourcePropertyType)) {
                // 将日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串
                if (Date.class.isAssignableFrom(sourcePropertyType) && String.class.isAssignableFrom(targetPropertyType)) {
                    targetValue = DateFormatUtils.format((Date) sourceValue, getDateFormat(targetPd.getName(), targetClass));
                }
                // 将yyyy-MM-dd HH:mm:ss类型的字符串自动转成日期类型
                else if (String.class.isAssignableFrom(sourcePropertyType) && Date.class.isAssignableFrom(targetPropertyType)) {
                    targetValue = DateUtils.parseDate((String) sourceValue, getDateFormat(targetPd.getName(), targetClass));
                }
                // 将枚举代码转换为枚举类型
                else if (IBaseEnum.class.isAssignableFrom(targetPropertyType)) {
                    targetValue = BaseEnumUtil.getEnumByCode(sourceValue, (Class<? extends IBaseEnum>) targetPropertyType);
                }
                // 将枚举类型转换为枚举代码
                else if (IBaseEnum.class.isAssignableFrom(sourcePropertyType)) {
                    IBaseEnum baseEnum = (IBaseEnum) sourceValue;
                    targetValue = baseEnum.getCode().getClass().isAssignableFrom(targetPropertyType) ? baseEnum.getCode() : baseEnum.getDesc();
                }
                // 目标类型指定为String,而源类型不是String的,调用String.valueOf()方法进行适配转换
                else if (String.class.isAssignableFrom(targetPropertyType)) {
                    targetValue = String.valueOf(sourceValue);
                }
            }
            return targetValue;
        }
    
        private static String getDateFormat(String targetPropertyName, Class<?> targetClass) {
    
            String key = targetClass.getName() + "-" + targetPropertyName;
            return DATE_FORMAT_CACHE.computeIfAbsent(key, o -> {
                DateFormat annotation = null;
                try {
                    Field field = targetClass.getDeclaredField(targetPropertyName);
                    annotation = field.getAnnotation(DateFormat.class);
                } catch (NoSuchFieldException e) {
                    LOGGER.error("no such field", e);
                }
                return Optional.ofNullable(annotation).map(DateFormat::value).orElse(DateUtil.DEFAULT_DATE_FORMAT);
            });
        }
    }
    
    

    **枚举工具类BaseEnumUtil **

    /**
     * 枚举工具类
     */
    public class BaseEnumUtil {
    
        private BaseEnumUtil() {
        }
    
        /**
         * 根据code获取枚举
         *
         * @param code     代码
         * @param enumType 枚举类型对象
         * @param <T>      枚举类型
         * @return 枚举
         */
        public static <T extends IBaseEnum> T getEnumByCode(Object code, Class<T> enumType) {
            if (code != null) {
                for (T t : enumType.getEnumConstants()) {
                    if (StringUtils.equals(String.valueOf(t.getCode()), String.valueOf(code))) {
                        return t;
                    }
                }
            }
            return null;
        }
    
        /**
         * 根据desc获取枚举
         *
         * @param desc     描述
         * @param enumType 枚举类型对象
         * @param <T>      枚举类型
         * @return 枚举
         */
        public static <T extends IBaseEnum> T getEnumByDesc(String desc, Class<T> enumType) {
            if (StringUtils.isNotBlank(desc)) {
                for (T t : enumType.getEnumConstants()) {
                    if (t.getDesc().equals(desc)) {
                        return t;
                    }
                }
            }
            return null;
        }
    
        /**
         * 根据code或者desc获取枚举
         *
         * @param code     代码或者描述
         * @param enumType 枚举类型对象
         * @param <T>      枚举类型
         * @return 枚举
         */
        public static <T extends IBaseEnum> T getEnumByCodeOrDesc(Object code, Class<T> enumType) {
            T result = getEnumByCode(code, enumType);
            if (result == null) {
                result = getEnumByDesc(ObjectUtils.toString(code), enumType);
            }
            return result;
        }
    }
    
    

    @DateFormat注解

    /**
     * 在使用BeanMapUtil进行Bean映射时,如果需要指定日期转换或者格式化的字符串格式,可以使用此注解指定
     * 具体使用方法为在目标类的日期字段或者日期字符串字段上加上此注解,并指定日期格式
     */
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface DateFormat {
    
        /**
         * 指定日期格式
         * @return 日期格式
         */
        String value() default DateUtil.DEFAULT_DATE_FORMAT;
    }
    
    

    IBaseEnum接口

    /**
     * 实现此接口的枚举类型能被Spring MVC接收参数时自动转换
     */
    public interface IBaseEnum<T> extends Serializable {
    
        /**
         * 返回枚举代码
         * @return 枚举代码
         */
        T getCode();
    
        /**
         * 返回枚举描述
         * @return 返回枚举描述
         */
        @JsonValue
        String getDesc();
    }
    
    
    展开全文
  • JAVA复制对象和集合的工具类 因为BeanUtils.copyProperties(Object source, Object target),只能复制对象,不能复制数组和集合,所以决定写个工具类来解决 public class CopyUtils { /** * 复制对象 */ public ...
  • Java对象复制

    千次阅读 2022-02-11 11:26:57
    Java对象复制(拷贝)
  • Java对象拷贝以及常用对象拷贝工具

    千次阅读 2021-04-10 22:49:18
    对象拷贝中常用的工具类2.1 Apache BeanUtils#copyProperties2.2 SpringUtils#copyProperties2.3 序列化(JSON)2.4 MapStruct(推荐) 1. 对象拷贝 Java语言中对象拷贝分为深拷贝和浅拷贝以及对象简单的引用拷贝...
  • 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 ...
  • 对象克隆、复制工具

    2018-07-31 16:25:37
    对象复制工具,基于cglib BeanCopier 实现对实体对象、持久化对象、代理对象的克隆和复制, 避免重复克隆和复制,避免无限循环引用,(校验hashCode) 可指定实体对象和集合属性的克隆深度
  • 在开发中经常遇到对象属性拷贝功能,而对象属性拷贝方式很多,比如手动set赋值,虽然麻烦,但是性能是最好的,其次MapStruct也是通过预编译完成,效率等同手动set,但是这两种相较于一些工具类稍微麻烦一些,一些...
  • Java对象复制三种方式

    千次阅读 2021-02-12 09:36:34
    Java对象复制三种方式概述在实际编程过程中,我们常常要遇到这种情况:有一个对象A,在某一时刻A中已经包含了一些有效值,此时可能 会需要一个和A完全相同新对象B,并且此后对B任何改动都不会影响到A中的值,也...
  • java复制对象的几种方法

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

    千次阅读 2022-01-14 11:08:12
    日常工作难免遇到调用其他项目接口,一般都是restful风格,这个并非强制风格,根据项目不同能使用的工具不同,主要受限于项目类型:maven项目,一般项目等。有原生http协议进行交互,java原生自带对http的支持并不...
  • 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复制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 Utils工具类大全

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

    千次阅读 2021-02-12 08:58:58
    出处:alteremjuejin.im/post/5d4a25b351882505c105cc6e在Java中,工具类定义了一组公共方法,这篇文章将介绍Java中使用最频繁及最通用的Java工具类。以下工具类、方法按使用流行度排名,参考数据来源于Github上随机...
  • java对象复制和属性值复制工具类

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

    千次阅读 2018-12-17 17:26:27
    Arrays 是JDK提供的操作数组的工具类,array类提供了动态创建和访问 Java 数组的方法。 arrays此类包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。主要有一下几...
  • 常用的Java工具类——十六种

    千次阅读 2021-02-27 08:52:03
    常用的Java工具类——十六种在Java中,工具类定义了一组公共方法,这篇文章将介绍Java中使用最频繁及最通用的Java工具类。以下工具类、方法按使用流行度排名,参考数据来源于Github上随机选取的5万个开源项目源码。...
  • JAVA常用的工具类

    万次阅读 多人点赞 2019-04-16 09:34:33
    4 对象属性及反射工具类 4.1 java.util.Objects Objects.isNull(integer);//对象为空 Objects.nonNull(integer);//对象不为空 Objects.requireNonNull(integer1, "参数不能为空");//对象为空抛异常 Objects.equals...
  • package main.java.java02.IO.fuzhi; import java.io.*; /** * @author:Mr.wang * @date:2019/2/21 0021 上午 10:32 ... //文件夹拷贝 不管是路径还是File对象都可直接使用 //拷贝文件夹方法 // Stri...
  • 直接上代码:BeanUtils 工具类 import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Set; import org.springframework.beans.BeanWrapper; ...
  • Java——Collections工具类

    千次阅读 2021-09-08 01:24:30
    Collections工具类 Collections 是一个操作 Set、List 和 Map 等集合的工具类 Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制...
  • Java中,工具类定义了一组公共方法,这篇文章将介绍Java中使用最频繁及最通用的Java工具类。 以下工具类、方法按使用流行度排名,参考数据来源于Github上随机选取的5万个开源项目源码。 一. org.apache.commons.io...
  • Java集合工具类Collections

    千次阅读 2022-03-29 10:31:15
    Java集合工具类Collections

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 159,592
精华内容 63,836
关键字:

java 复制对象工具类

java 订阅