Consider the code below:
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'
So, I want to copy the dum
to dumtwo
and change dum
without affecting the dumtwo
. But the code above is not doing that. When I change something in dum
, the same change is happening in dumtwo
also.
I guess, when I say dumtwo = dum
, Java copies the reference only. So, is there any way to create a fresh copy of dum
and assign it to dumtwo
?
I use Google's JSON library to serialize it then create a new instance of the serialized object. It does deep copy with a few restrictions:
there can't be any recursive references
it won't copy arrays of disparate types
arrays and lists should be typed or it won't find the class to instantiate
you may need to encapsulate strings in a class you declare yourself
I also use this class to save user preferences, windows and whatnot to be reloaded at runtime. It is very easy to use and effective.
Yes. You need to Deep Copy your object.
Use a deep cloning utility:
This will deep copy any java object, check it out at https://github.com/kostaskougios/cloning
Basic: Object Copying in Java.
Let us Assume an object-
obj1
, that contains two objects, containedObj1 and containedObj2.shallow copying:
shallow copying creates a new
instance
of the same class and copies all the fields to the new instance and returns it. Object class provides aclone
method and provides support for the shallow copying.Deep copying:
A deep copy occurs when an object is copied along with the objects to which it refers. Below image shows
obj1
after a deep copy has been performed on it. Not only hasobj1
been copied, but the objects contained within it have been copied as well. We can useJava Object Serialization
to make a deep copy. Unfortunately, this approach has some problems too(detailed examples).Possible Problems:
clone
is tricky to implement correctly.It's better to use Defensive copying, copy constructors(as @egaga reply) or static factory methods.
clone()
method, but you don’t know the type of the object at compile time, then you have problem. Java has an interface calledCloneable
. In practice, we should implement this interface if we want to make an objectCloneable
.Object.clone
is protected, so we must override it with a public method in order for it to be accessible.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.For example org.apache.commons.lang.SerializationUtils will have method for Deep clone using serialization(Source). If we need to clone Bean then there are couple of utility methods in org.apache.commons.beanutils (Source).
cloneBean
will Clone a bean based on the available property getters and setters, even if the bean class itself does not implement Cloneable.copyProperties
will Copy property values from the origin bean to the destination bean for all cases where the property names are the same.To do that you have to clone the object in some way. Although Java has a cloning mechanism, don't use it if you don't have to. Create a copy method that does the copy work for you, and then do:
Here is some more advice on different techniques for accomplishing a copy.
If you can add an annotation to the source file, an annotation processor or code generator like this one can be used.
A class
DummyBeanBuilders
will be generates, which has a static methoddummyBeanUpdater
to create shallow copies, the same way as you would do it manually.