第一种：使用org.apache.commons.beanutils.PropertyUtils.copyProperties()拷贝一个bean中的属性到另一个bean中,第一个参数是目标bean,第二个参数是源bean。
 
特点：
 
1.它的性能问题相当差
 
2.PropertyUtils有自动类型转换功能，而java.util.Date恰恰是其不支持的类型
 
3.PropertyUtils支持为null的场景；
 
public static void copyProperties(Object dest, Object orig) {
try {
 PropertyUtils.copyProperties(dest, orig);
} catch (IllegalAccessException | InvocationTargetException
throw new IllegalArgumentException(e);
| NoSuchMethodException e) { }
}
 
第二种：使用BeanUtils.copyProperties()拷贝一个bean中的属性到另一个bean中,第一个参数是目标bean,第二个参数是源bean。
 
特点：
 
1.BeanUtils速度相对快一些
 
2.BeanUtils没有自动转换功能，遇到参数名相同，类型不同的参数不会进行赋值。
 
3.BeanUtils对部分属性不支持null的情况,Ineger、Boolean、Long等不支持。
 
public static void copyProperties(Object dest, Object orig) {
try {
 BeanUtils.copyProperties(dest, orig);
} catch (IllegalAccessException | InvocationTargetException e) {
throw new IllegalArgumentException(e);
}
}
 
第三种：将java对象转换为json，然后将JSON转换成Java对象。注意属性名要相同—采取com.fasterxml.jackson.databind.ObjectMapper的方法
 
特点：
 
1.属性名一致就可以转换
 
2.效率及异常还未验证
 
private static final ObjectMapper MAPPER = new ObjectMapper();
String jsonStr = MAPPER.writeValueAsString(obj);
RabbitMQDataDto detail = MAPPER.readValue(jsonStr , RabbitMQDataDto.class);
 
第四种：将java对象转换为json，然后将JSON转换成Java对象。注意属性名要相同—采取com.alibaba.fastjson.JSON
 
特点：
 
1.需要拷贝的两个对象里面都包含有另一个对象，但是另一个对象里面属性相同但是对象名不同；
 
采用json来转换只要属性名一致即可
 
InsurePersonInfoDto applicantInfo = insureRelevantPersonInfoDto.getApplicantInfo();
ThirdPartInsurePersonInfo thirdPartApplicantInfo = JSON.parseObject(JSON.toJSONString(applicantInfo), new TypeReference<ThirdPartInsurePersonInfo>() {});
 
第五种Dozer
 
1、Dozer是什么？
 dozer是一个能把实体和实体之间进行转换的工具.只要建立好映射关系.就像是ORM的数据库和实体映射一样.
 
使用方法示例如下:
 
// article(PO) -> articleVO
ArticleVO articleVO = dozerMapper.map(article, ArticleVO.class);
 
这段示例代码。将从数据库里面查询得到的PO对象article，转换为VO对象articleVO，转换过程将所有同名同类型的数据自动赋值给articleVO的成员变量，当然除了reader(因为PO里面没有reader数组数据)。转换需要写属性之间的映射么?不! 默认是根据属性名称来匹配的.
 
2、使用Dozer进行实体类的转换:
 
首先引入依赖
 
 <dependency>
  <groupId>net.sf.dozer</groupId>
  <artifactId>dozer</artifactId>
  <version>5.4.0</version>
 </dependency>
 
注入一个工具类DozerBeanMapper 到上下文中，
 
 @Configuration
 public class DozerBeanMapperConfigure {
  @Bean
  public DozerBeanMapper mapper() {
   DozerBeanMapper mapper = new DozerBeanMapper();
   return mapper;
  }
 }
 
注入然后开始使用
 
@Autowired
protected Mapper dozerMapper;
 
在实际应用中，我们不只需要PO转VO，有时还需要List转List.写一个工具类，实现List转List
 
public class DozerUtils {

 static DozerBeanMapper dozerBeanMapper = new DozerBeanMapper();

 public static <T> List<T> mapList(Collection sourceList, Class<T> destinationClass){
  List destinationList = Lists.newArrayList();
  for (Iterator i$ = sourceList.iterator(); i$.hasNext();){
   Object sourceObject = i$.next();
   Object destinationObject = dozerBeanMapper.map(sourceObject, destinationClass);
   destinationList.add(destinationObject);
  }
  return destinationList;
 }
}
 
转自：https://www.jb51.net/article/193804.htm
 Dozer可以参考http://dozer.sourceforge.net/documentation/springintegration.html

         赋值是用等号运算符（=）进行的。它的意思是“取得右边的值，把它复制到左边”。右边的值可以是任何常数、变量或者表达式，只要能产生一个值就行。但左边的值必须是一个明确的、已命名的变量。也就是说，它必须有一个物理性的空间来保存右边的值。举个例子来说，可将一个常数赋给一个变量（A=4;），但不可将任何东西赋给一个常数（比如不能4=A）。
 
        对主数据类型的赋值是非常直接的。由于主类型容纳了实际的值，而且并非指向一个对象的句柄，所以在为其赋值的时候，可将来自一个地方的内容复制到另一个地方。例如，假设为主类型使用“A=B”，那么B处的内容就复制到A。若接着又修改了A，那么B根本不会受这种修改的影响。作为一名程序员，这应成为自己的常识。
 
但在为对象“赋值”的时候，情况却发生了变化。对一个对象进行操作时，我们真正操作的是它的句柄。所以倘若“从一个对象到另一个对象”赋值，实际就是将句柄从一个地方复制到另一个地方。这意味着假若为对象使用“C=D”，那么C和D最终都会指向最初只有D才指向的那个对象。下面这个例子将向大家阐示这一点。
 
 
 
下面是例子：
 
 
</pre><pre name="code" class="java">class Number {
  int i;
}

public class Assignment {
  public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    n1.i = 9;
    n2.i = 47;
    System.out.println("1: n1.i: " + n1.i +
      ", n2.i: " + n2.i);
    n1 = n2;
    System.out.println("2: n1.i: " + n1.i +
      ", n2.i: " + n2.i);
    n1.i = 27;
    System.out.println("3: n1.i: " + n1.i +
      ", n2.i: " + n2.i);
  }
}

          Number类非常简单，它的两个实例（n1和n2）是在main()里创建的。每个Number中的i值都赋予了一个不同的值。随后，将n2赋给n1，而且n1发生改变。在许多程序设计语言中，我们都希望n1和n2任何时候都相互独立。但由于我们已赋予了一个句柄，所以下面才是真实的输出： 
1: n1.i: 9, n2.i: 47
 
2: n1.i: 47, n2.i: 47
 
3: n1.i: 27, n2.i: 27
 
         看来改变n1的同时也改变了n2！这是由于无论n1还是n2都包含了相同的句柄，它指向相同的对象（最初的句柄位于n1内部，指向容纳了值9的一个对象。在赋值过程中，那个句柄实际已经丢失；它的对象会由“垃圾收集器”自动清除）。
 
         这种特殊的现象通常也叫作“别名”，是Java操作对象的一种基本方式。但假若不愿意在这种情况下出现别名，又该怎么操作呢？可放弃赋值，并写入下述代码：
 
n1.i = n2.i;
 
           这样便可保留两个独立的对象，而不是将n1和n2绑定到相同的对象。但您很快就会意识到，这样做会使对象内部的字段处理发生混乱，并与标准的面向对象设计准则相悖。

开篇第一句,还是那句老话: 先学会走,再想着跑.
 
首先我们假设: 有一个冰箱的类,并且冰箱类中有一个冰箱品牌的 (brand) 成员
 
变量.考虑到冰箱的英文很长,有很多人并不认识,以下我会使用 bingxiang 来叙述.
 
BingXing bingXing = new BingXIng();
bingXiang.brand="海尔";
BingXing bingXiang2=bingXiang; 
 
对于 bingXiang2 我并没有 new 生成一个新的对象,而是把 bingXiang 直接赋给
 
了它,这时候大家要注意,如果是引用类型的赋值的话,是把 bingxiang 的内存地
 
址赋给了bingXiang2, 也就是说这个时候他们两个引用了同一块内存地址.
 
System.out.println(bingXiang.brand);
System.out.println(bingXiang2.brand);
 
输出结果为:
 
海尔
海尔
 
现在我们修改 bingXiang2 的种类,再看输出结果
 
bingXiang.brand2="美的";
System.out.println(bingXiang.brand);
System.out.println(bingXiang2.brand);
 
输出结果为:
 
美的
美的
 
同过这两个例子我们可以很清楚的发现他们两个 确实引用了同一块内存地址.
 
接下来我在为大家画一张内存的分布图,让大家更好的理解:
 
 我们直接把 bingXiang 赋值给了 bingXiang2 所以两个对象中存储着相同的地
 
址,都是58. 从图中可以清楚的看出两个对象引用了同一块内存地址.

 
对象之间的属性赋值
 
主要通过org.springframework.beans.BeanUtils.copyProperties方法进行对象之间的属性赋值。
 
赋值前提 -- 两个对象要赋值的属性名需要保持一致
 
对象赋值
 
# 将source对象赋值给target对象
 
BeanUtils.copyProperties(source, target);
 
List之间的对象赋值
 
/**
 
* @param input 输入集合
 
* @param clazz 输出集合类型
 
* @param 输入集合类型
 
* @param 输出集合类型
 
* @return 返回集合
 
*/
 
public static List convertListToList(List input, Class clazz) {
 
List output = Lists.newArrayList();
 
if (CollectionUtils.isNotEmpty(input)) {
 
for (E source : input) {
 
T target = BeanUtils.instantiate(clazz);
 
BeanUtils.copyProperties(source, target);
 
output.add(target);
 
}
 
}
 
return output;
 
}
 
示例
 
有以下三个类，User、Cust、Student：
 
@Data
 
public class User {
 
private String name;
 
private String password;
 
private String email;
 
}
 
@Data
 
public class Cust {
 
private String name;
 
private String password;
 
private String email;
 
private String phone;
 
}
 
@Data
 
public class Student {
 
private String name;
 
private String password;
 
}
 
工具类：
 
import com.google.common.collect.Lists;
 
import org.apache.commons.collections.CollectionUtils;
 
import org.springframework.beans.BeanUtils;
 
import java.util.List;
 
/**
 
* @Description: 对象之间进行赋值
 
* @Date: 2020/9/25 9:55
 
*/
 
public class AssignmentObject {
 
/**
 
* 对象属性拷贝
 
* 将源对象的属性拷贝到目标对象
 
* @param source 源对象
 
* @param target 目标对象
 
*/
 
public static void copyProperties(Object source, Object target) {
 
BeanUtils.copyProperties(source, target);
 
}
 
/**
 
* @param input 输入集合
 
* @param clazz 输出集合类型
 
* @param 输入集合类型
 
* @param 输出集合类型
 
* @return 返回集合
 
*/
 
public static List convertListToList(List input, Class clazz) {
 
List output = Lists.newArrayList();
 
if (CollectionUtils.isNotEmpty(input)) {
 
for (E source : input) {
 
T target = BeanUtils.instantiate(clazz);
 
BeanUtils.copyProperties(source, target);
 
output.add(target);
 
}
 
}
 
return output;
 
}
 
}
 
测试类：分别测试对象之间的属性赋值与List之间的属性赋值
 
public class Demo {
 
public static void main(String[] args) {
 
User user = new User();
 
user.setName("admin");
 
user.setPassword("admin");
 
user.setEmail("123@qq.com");
 
System.out.println("user:" + user);
 
// 将user的属性分别赋给cust和student
 
Cust cust = new Cust();
 
AssignmentObject.copyProperties(user, cust);
 
System.out.println("cust:" + cust);
 
Student student = new Student();
 
AssignmentObject.copyProperties(user, student);
 
System.out.println("student:" + student);
 
User user1 = new User();
 
user1.setName("demo");
 
user1.setPassword("demo");
 
user1.setEmail("demo@qq.com");
 
System.out.println("user1:" + user);
 
// 将users赋值给List和List
 
List users = new ArrayList<>();
 
users.add(user);
 
users.add(user1);
 
System.out.println("users:" + users);
 
List custs = AssignmentObject.convertListToList(users, Cust.class);
 
System.out.println("custs:" + custs);
 
List students = AssignmentObject.convertListToList(users, Student.class);
 
System.out.println("students:" + students);
 
}
 
}