考虑下面的代码:
DummyBean dum = new DummyBean();
dum.setDummy("foo");
System.out.println(dum.getDummy()); // prints 'foo'
DummyBean dumtwo = dum;
System.out.println(dumtwo.getDummy()); // prints 'foo'
dum.setDummy("bar");
System.out.println(dumtwo.getDummy()); // prints 'bar' but it should print 'foo'
所以，我想把dumm复制到dum2，在不影响dum2的情况下改变dumm。但是上面的代码并没有这样做。当我改变了dumm中的一些东西，同样的变化也会发生在dum2中。
我想，当我说dumtwo = dum时，Java只复制了引用。那么，有没有办法创建一个新的dum副本并将其分配给dumtwo呢?
当前回答
为什么使用反射API没有答案?
private static Object cloneObject(Object obj){
try{
Object clone = obj.getClass().newInstance();
for (Field field : obj.getClass().getDeclaredFields()) {
field.setAccessible(true);
field.set(clone, field.get(obj));
}
return clone;
}catch(Exception e){
return null;
}
}
这真的很简单。
EDIT:通过递归包含子对象
private static Object cloneObject(Object obj){
try{
Object clone = obj.getClass().newInstance();
for (Field field : obj.getClass().getDeclaredFields()) {
field.setAccessible(true);
if(field.get(obj) == null || Modifier.isFinal(field.getModifiers())){
continue;
}
if(field.getType().isPrimitive() || field.getType().equals(String.class)
|| field.getType().getSuperclass().equals(Number.class)
|| field.getType().equals(Boolean.class)){
field.set(clone, field.get(obj));
}else{
Object childObj = field.get(obj);
if(childObj == obj){
field.set(clone, clone);
}else{
field.set(clone, cloneObject(field.get(obj)));
}
}
}
return clone;
}catch(Exception e){
return null;
}
}
其他回答
要做到这一点，你必须以某种方式克隆对象。虽然Java有克隆机制，但如果没有必要就不要使用它。创建一个复制方法，为你做复制工作，然后做:
dumtwo = dum.copy();
这里有一些关于完成副本的不同技巧的建议。
使用Kotlin扩展函数
fun <T : Any?> T.duplicate(): T? {
var copyObject: T? = null
try {
val byteArrayOutputStream = ByteArrayOutputStream()
val objectOutputStream = ObjectOutputStream(byteArrayOutputStream)
objectOutputStream.writeObject(this)
objectOutputStream.flush()
objectOutputStream.close()
byteArrayOutputStream.close()
val byteData = byteArrayOutputStream.toByteArray()
val byteArrayInputStream = ByteArrayInputStream(byteData)
try {
copyObject = ObjectInputStream(byteArrayInputStream).readObject() as T
} catch (e: ClassNotFoundException) {
e.printStackTrace()
}
} catch (e: IOException) {
e.printStackTrace()
}
return copyObject
}
用例
var object = Any()
var duplicateObject = object.duplicate()
Java
<T extends Object> T copyObject(T sourceObject) {
T copyObject = null;
try {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(sourceObject);
objectOutputStream.flush();
objectOutputStream.close();
byteArrayOutputStream.close();
byte[] byteData = byteArrayOutputStream.toByteArray();
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteData);
try {
copyObject = (T) new ObjectInputStream(byteArrayInputStream).readObject();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}
return copyObject;
}
用例
Object object = new Object();
Object duplicateObject = copyObject(object);
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
芬兰湾的科特林更新
如果您使用数据类，那么您将有复制方法来复制Kotlin数据类。很酷的是，你还可以通过一些值来修改对象的新副本。我推荐这种方式。
例子:
/ /类
data class TestModel(val title: String, var subtitle: String)
用例
val testClass = TestModel("Test title", "Test subtitle")
val newInstance = testClass.copy(subtitle = "new subtitle for copy instance")
为什么使用反射API没有答案?
private static Object cloneObject(Object obj){
try{
Object clone = obj.getClass().newInstance();
for (Field field : obj.getClass().getDeclaredFields()) {
field.setAccessible(true);
field.set(clone, field.get(obj));
}
return clone;
}catch(Exception e){
return null;
}
}
这真的很简单。
EDIT:通过递归包含子对象
private static Object cloneObject(Object obj){
try{
Object clone = obj.getClass().newInstance();
for (Field field : obj.getClass().getDeclaredFields()) {
field.setAccessible(true);
if(field.get(obj) == null || Modifier.isFinal(field.getModifiers())){
continue;
}
if(field.getType().isPrimitive() || field.getType().equals(String.class)
|| field.getType().getSuperclass().equals(Number.class)
|| field.getType().equals(Boolean.class)){
field.set(clone, field.get(obj));
}else{
Object childObj = field.get(obj);
if(childObj == obj){
field.set(clone, clone);
}else{
field.set(clone, cloneObject(field.get(obj)));
}
}
}
return clone;
}catch(Exception e){
return null;
}
}
在包中导入org.apache.commons.lang.SerializationUtils;有一种方法:
SerializationUtils.clone(Object);
例子:
this.myObjectCloned = SerializationUtils.clone(this.object);
基本:Java对象复制。
让我们假设一个对象——obj1，它包含两个对象，containedObj1和containedObj2。
浅复制: 浅复制创建同一个类的新实例，并将所有字段复制到新实例并返回它。类提供了克隆方法，并提供了对浅复制的支持。
深复制: 当对象与其引用的对象一起复制时，就会发生深度复制。下图显示obj1在深度复制后被执行。不仅obj1被复制了，它包含的对象也被复制了。我们可以使用Java对象序列化来进行深度复制。不幸的是，这种方法也有一些问题(详细的示例)。
可能的问题: 克隆是很难正确实现的。 最好使用防御性复制、复制构造函数(如@egaga reply)或静态工厂方法。
If you have an object, that you know has a public clone() method, but you don’t know the type of the object at compile time, then you have problem. Java has an interface called Cloneable. In practice, we should implement this interface if we want to make an object Cloneable. Object.clone is protected, so we must override it with a public method in order for it to be accessible. Another problem arises when we try deep copying of a complex object. Assume that the clone() method of all member object variables also does deep copy, this is too risky of an assumption. You must control the code in all classes.
例如，org.apache.commons.lang.SerializationUtils将有使用序列化进行深度克隆的方法(源代码)。如果我们需要克隆Bean，那么在org.apache.commons.beanutils (Source)中有两个实用程序方法。
cloneBean将基于可用的属性getter和setter克隆一个bean，即使bean类本身没有实现Cloneable。 copyProperties将在所有属性名称相同的情况下，将属性值从源bean复制到目标bean。
