深拷贝与浅拷贝的区别
浅拷贝只是拷贝了源对象的地址，所以当源对象发生改变时，拷贝的对象的值也会对应发生改变。 深拷贝则是拷贝了源对象的所有值，而不是地址，所以深拷贝对象中的值不会随着源对象中的值的改变而改变。
浅拷贝只是拷贝了源对象的地址，所以当源对象发生改变时，拷贝的对象的值也会对应发生改变！！！这块儿要注意，有坑！
发生的场景
当如果要拷贝一个A对象，而A对象中又有一个B对象，那么如果对A拷贝的时候，重新拷贝出来一个A1对象并且重新分配内存地址， 但是对于A中的B对象，仅仅只是把A1中拷贝出来的B1对象的引用指向原来的B对象而已， 并没有把拷贝的B1对象也重新进行分配一个新的内存地址。这就是浅拷贝。 而深拷贝就是在第1的基础上，不仅重新给A1对象分配了新的内存地址，而且还给A1中的B1也重新进行分配了新的内存地址， 而不只是仅仅把原本的B的引用给B1。这就是深拷贝。
最基本的实现实现
如果要深拷贝一个对象，那么这个对象必须要实现 Cloneable 接口，实现 重写clone（）方法， 并且在 clone 方法内部，把该对象引用的其他对象也要 clone 一份， 这就要求这个被引用的对象必须也要实现Cloneable 接口并且实现 clone 方法
利用反射机制实现
public static void copy(Object source, Object dest) throws Exception {Class destClz = dest.getClass();// 获取目标的所有成员Field[] destFields = destClz.getDeclaredFields();Object value;for (Field field : destFields) { // 遍历所有的成员，并赋值// 获取value值value = getVal(field.getName(), source);field.setAccessible(true);field.set(dest, value);}
}private static Object getVal(String name, Object obj) throws Exception {try {// 优先获取obj中同名的成员变量Field field = obj.getClass().getDeclaredField(name);field.setAccessible(true);return field.get(obj);} catch (NoSuchFieldException e) {// 表示没有同名的变量}// 获取对应的 getXxx() 或者 isXxx() 方法name = name.substring(0, 1).toUpperCase() + name.substring(1);String methodName = "get" + name;String methodName2 = "is" + name;Method[] methods = obj.getClass().getMethods();for (Method method : methods) {// 只获取无参的方法if (method.getParameterCount() > 0) {continue;}if (method.getName().equals(methodName)|| method.getName().equals(methodName2)) {return method.invoke(obj);}}return null;
}
直接上BeanUtil工具类型
package com.bboss.common.util;import com.github.dozermapper.core.DozerBeanMapperBuilder;
import com.github.dozermapper.core.Mapper;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.core.Converter;
import org.springframework.util.ObjectUtils;import java.lang.ref.SoftReference;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;public class BeanUtil {/** 创建默认的DozerBeanMapper*/private static Mapper beanMapper = DozerBeanMapperBuilder.buildDefault();/** BeanCopier的类型缓存map*/private static final ConcurrentHashMap<String, SoftReference<BeanCopier>> BEAN_COPIER_CACHE = new ConcurrentHashMap<>();/*** @description 生成key* @param srcClazz 源文件的class* @param tgtClazz 目标文件的class* @return string* @author yanb* @date 2020/8/01*/private static String generateKey(Class<?> srcClazz, Class<?> tgtClazz) {StringBuilder sb=new StringBuilder(srcClazz.getName()).append(":").append(tgtClazz.getName());return sb.toString().intern();}/*** bean对象（属性）拷贝* 浅拷贝，高性能* @param source 源对象* @param target 目标对象* @descriptio BeanCopier的copy* @author yanb* @date 2020/8/01*/public static void copy(Object source, Object target) {copy(source, target, null);}/*** 支持自定义converter的拷贝方法* 浅拷贝，高性能*/public static void copy(Object source, Object target, Converter converter) {if (Objects.isNull(source) || Objects.isNull(target)) {return;}String key = generateKey(source.getClass(), target.getClass());BeanCopier beanCopier;if (Objects.isNull(BEAN_COPIER_CACHE.get(key))|| Objects.isNull(beanCopier = BEAN_COPIER_CACHE.get(key).get())) {synchronized (key) {if (Objects.isNull(BEAN_COPIER_CACHE.get(key))|| Objects.isNull(beanCopier = BEAN_COPIER_CACHE.get(key).get())) {beanCopier = BeanCopier.create(source.getClass(), target.getClass(), Objects.nonNull(converter));BEAN_COPIER_CACHE.put(key, new SoftReference<>(beanCopier));}}}beanCopier.copy(source, target, converter);}/* ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ 上面是浅拷贝方法 ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ *//* ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● 华丽的分割线 ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● ●▂● *//* ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ 下面是深拷贝方法 ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ *//*** List拷贝，直接返回list对象* 深拷贝* @param source 源对象* @param destinationClass 目标类型* @return java.util.List<U>* @author yanb* @date 2020/8/01*/public static <T, U> List<U> mapList(final List<T> source, final Class<U> destinationClass) {if (Objects.isNull(source) || Objects.isNull(destinationClass)) {return null;}final List<U> dest = new ArrayList<U>();for (T element : source) {dest.add(beanMapper.map(element, destinationClass));}return dest;}/*** Collection拷贝，直接返回Collection对象* 深拷贝* @param source 源对象* @param destinationClass 目标类型* @return java.util.List<U>* @author yanb* @date 2020/8/01*/public static <T, U> Collection<U> mapCollection(final Collection<T> source, final Class<U> destinationClass) {if (Objects.isNull(source)||Objects.isNull(destinationClass)) {return null;}final Collection<U> dest = new ArrayList<>();for (T element : source) {dest.add(beanMapper.map(element, destinationClass));}return dest;}/*** 单个对象的 深拷贝* 生成新的对象* @param source 源对象* @param destinationClass 目标类型* @return U* @author yanb* @date 2021/3/17*/public static <T, U> U deepCopy(final T source, Class<U> destinationClass) {if (Objects.isNull(source) || Objects.isNull(destinationClass)){return null;}return beanMapper.map(source, destinationClass);}/*** 单个对象的 深拷贝* @param source 源对象* @param target 目标对象* @return void* @author yanb* @date 2021/3/17*/public static <U> void deepCopy(Object source, Object target) {if (Objects.isNull(source) || Objects.isNull(target)) {return;}beanMapper.map(source, target);}public static boolean allFieldIsNULL(Object o) {try {Field[] var1 = o.getClass().getDeclaredFields();int var2 = var1.length;for(int var3 = 0; var3 < var2; ++var3) {Field field = var1[var3];field.setAccessible(true);Object object = field.get(o);if (object instanceof CharSequence) {if (!ObjectUtils.isEmpty(object)) {return false;}} else if (null != object) {return false;}}} catch (Exception var6) {}return true;}}
直接调用上面工具类中的mapList
List<CustBlack> custBlacksCopy = BeanUtil.mapList(custBlacks,CustBlack.class);
