Java中把一个对象的值复制给另外一个对象引发的思考
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Java中把一个对象的值复制给另外一个对象引发的思考，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6494字，纯文字阅读大概需要10分钟。
内容图文
Spring生态在Java项目中被广泛应用，从架构到技术应用再到常用的基本功能，Spring给我们的开发带来了很大的便利。今天翻到项目中导出报表功能的时候，发现经常复制对象的方法：
BeanUtils.copyProperties;
把源对象的属性值赋值给目标对象，Spring和Apache和其他的一些框架都给我们提供了对象属性的拷贝方法：
org.springframework.beans.BeanUtils.copyProperties(Object source, Object target)
org.apache.commons.beanutils.BeanUtils.copyProperties(Object dest, Object orig)
使用的时候注意这两个方法的参数顺序，源和目标是相反的。这两个方法底层都用到了反射，心血来潮之下我自己造了一个对象拷贝的轮子，代码如下：
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.HashMap;
public class ObjConvertor {
private static HashMap<String,HashMap<String,Method>> mapSetMethods=new HashMap<String,HashMap<String,Method>>();
private static HashMap<String,HashMap<String,Method>> mapGetMethods=new HashMap<String,HashMap<String,Method>>();
static
{
}
public static boolean Convert(Object src,Object dst) {
HashMap<String,Method> mapSrc=new HashMap<String,Method>();
HashMap<String,Method> mapDst=new HashMap<String,Method>();
if(mapGetMethods.containsKey(src.getClass().getTypeName()))
mapSrc=mapGetMethods.get(src.getClass().getTypeName());
else
{
Method srcMethods[]=src.getClass().getMethods();
mapGetMethods.put(src.getClass().getTypeName(),mapSrc);
for(Method method:srcMethods)
{
String name=method.getName();
if(name.startsWith("get"))
{
String prop=name.substring(3).toLowerCase();
mapSrc.put(prop, method);
}
}
}
if(mapSetMethods.containsKey(dst.getClass().getTypeName()))
mapDst=mapSetMethods.get(dst.getClass().getTypeName());
else
{
Method dstMethods[]=dst.getClass().getMethods();
mapSetMethods.put(dst.getClass().getTypeName(),mapDst);
for(Method method:dstMethods)
{
String name=method.getName();
if(name.startsWith("set"))
{
String prop=name.substring(3).toLowerCase();
mapDst.put(prop, method);
}
}
}
for(String prop:mapSrc.keySet())
{
if(mapDst.containsKey(prop)){
Method setMethod=mapDst.get(prop);
Method getMethod=mapSrc.get(prop);
try {
Object data=getMethod.invoke(src);
if(data==null)
continue;
if(data instanceof java.sql.Time)
{
if(setMethod.getParameterTypes()[0]==String.class)
data=data.toString();
}
else if(data instanceof java.sql.Date)
{
if(setMethod.getParameterTypes()[0]==String.class)
data=new SimpleDateFormat("yyyy-MM-dd").format(data);
}
else if(data instanceof java.util.Date)
{
if(setMethod.getParameterTypes()[0]==String.class)
data=new SimpleDateFormat("yyyy-MM-dd").format((java.util.Date)data);
}
else if(data instanceof java.sql.Timestamp)
{
if(setMethod.getParameterTypes()[0]==String.class)
data=data.toString();
}
if(setMethod.getParameterTypes()[0]==java.sql.Time.class)
{
if(data instanceof String)
data=java.sql.Time.valueOf((String)data);
}
else if(setMethod.getParameterTypes()[0]==java.sql.Date.class)
{
if(data instanceof String)
data=java.sql.Date.valueOf((String)data);
}
else if(setMethod.getParameterTypes()[0]==java.util.Date.class)
{
if(data instanceof String)
{
data=(new SimpleDateFormat("yyyy-MM-dd")).parse((String)data);
}
}
else if(setMethod.getParameterTypes()[0]==java.sql.Timestamp.class)
{
if(data instanceof String)
data=java.sql.Timestamp.valueOf((String)data);
}
if(data==null)
continue;
setMethod.invoke(dst, data);
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
}
}
}
return true;
}
}
对象拷贝的功能至此完结，如果项目中需要一些特殊格式的数据，可以考虑自己造轮子，这个就看业务需求了。
接下来谈谈对象拷贝，如果在拷贝这个对象的时候，只对基本数据类型进行了拷贝，而对引用数据类型只是进行引用的传递，而没有真实的创建一个新的对象，则认为是浅拷贝，比如Spring和Apache的copyProperties和上面自己的拷贝方法。反过来，在对引用数据类型进行拷贝的时候，创建了一个新的对象，并且复制其内的成员变量，则认为是深拷贝。
通过对比不难发现：深拷贝相当于创建了一个新的对象，只是这个对象的所有内容，都和被拷贝的对象一模一样，即两者的修改是隔离的，相互之间没有影响；而浅拷贝也是创建了一个对象，但是这个对象的某些内容（比如A）依然是被拷贝对象的，即通过这两个对象中任意一个修改A，两个对象的A都会受到影响。
Spring和Apache的copyProperties都属于浅拷贝，在日常开发中基本可以满足使用了。需要注意的是，在Java开发手册中提到，不建议用Apache的BeanUtils工具类，因为其中有很多的检验、类型转换、日志打印等，实现复杂度高，性能比较差。
那么如果要实现高性能且安全的深度拷贝呢？深拷贝就是被拷贝对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量，那些引用其他对象的变量将指向被拷贝过的新对象，而不再试原有的那些被引用的对象，就是说，深拷贝把要拷贝的对象所引用的对象都复制了一遍。我觉得最靠谱的深拷贝还是要用序列化后写流的方法，这种方法需要实现Serializable接口，多层拷贝时，引用类型都要实现Serializable接口。代码如下：
import java.io.*;
import java.util.Date;
public class CopyDemo {
class User implements Serializable {
private int id;
private String username;// 用户姓名
private String sex;// 性别
private Date birthday;// 生日
private String address;// 地址
private Person person; //引用类型
public User myColon(){
User copy=null;
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
//将流序列化成对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
copy = (User) ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return copy;
}
//省略get-set方法代码
}
class Person implements Serializable {
private int id;
private String userName ;
private int age ;
private String mobilePhone ;
public Person(){}
public Person(int id,String userName, int age, String mobilePhone) {
this.id = id;
this.userName = userName;
this.age = age;
this.mobilePhone = mobilePhone;
}
//省略get-set方法
}
}
在Java语言里深拷贝一个对象，先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。通过代码可以更明显的看到这个过程。把对象写到流里的过程是串行化（Serilization）过程，而把对象从流中读出来是并行化（Deserialization）过程。需要注意的是，需要拷贝的对象可能包含多层引用类型，多层拷贝不仅要将拷贝对象实现序列化接口，引用对象也同样的要实现序列化接口。
内容总结
以上是互联网集市为您收集整理的Java中把一个对象的值复制给另外一个对象引发的思考全部内容，希望文章能够帮你解决Java中把一个对象的值复制给另外一个对象引发的思考所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。