0

I am having array of collection of objects and i am passing this reference to method and the method will do some biz logic and updates the objects so it will reflect in original object since i m passing it as reference . Now my question is how to avoid this update of original object.

If cloning is involved please let me know what kind of clone i need to do for the above case

Thx

Improve this question
2
  • Immutable objects FOR THE AWESOMES! Commented Dec 19, 2010 at 3:09
  • You should probably reimplement Object.clone() method. See its docs. Commented Dec 19, 2010 at 5:55

4 Answers 4

Reset to default
4

Your situation is a bit tricky:

You have an array of references to objects.

Java is always pass by value, so when you pass the reference to the array into the method, the reference to the array is passed by value.

So the method has a new reference to the same array as the calling scope.

The answer to your question is: if you don't want your changes to reflect in the objects, you need to copy the objects. So, to go thru it.

  1. You have an array of object references.
  2. You want to do some work based off the objects, but you don't want to modify the objects.
  3. You should create an array of objects -- the objects in this array are copies of the original array.
  4. By 'copy' I do NOT mean just do Object copy = original. You will need to create a new Object which is the copy. It might be a good idea to have a getCopy() method on the relevant class that creates copies of an instance. This can be complicated if your Objects have children or are otherwise contain other objects.
  5. You pass the array of copies into the method that does the stuff.
Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

@javauser without seeing the class involved, its hard to say what to do, other than to make a copy. As I suggested in point 4, a simple way to do it would be to add a createCopy() method to the class that creates a duplicate of the current object.
3

If you want the original objects to remain unchanged, you need to make the changes to copies of the original objects. This implies a "deep copy" of the array, where you're not just creating a second array with references to the same objects, but making copies of each object in the array as well.

Depending on who should own the changed objects (if anyone), you can create this copy in the caller and pass it in, or pass in the original array and have the method make a set of copies. The first one seems more logical, but without knowing more about your design it's hard to say.

Improve this answer

Comments

0

You may use Collections.copy(dest, src) it will make a deep copy of your array. But, becase of a bug in the method, you should do some trick:

//Assuming, that src is an array

List<Integer> src2 = Arrays.asList(src)

List<Integer> dest = new ArrayList<Integer>(src2);

Collections.copy(dest, src2);

Actually, you dont have to pass the source array to construct the destiantion array. You have to pass an array with the same size as the source array.

Improve this answer

Comments

0

There are a number of approaches to stopping a method making changes to an object passed as a parameter:

  • Make a copy of the object, and pass the copy. There are a variety of ways of copying objects. Copy constructors and static factory methods are probably better than implementing clone().
  • Create a read-only wrapper class for the object's class, instantiate it and pass it. The read-only wrapper either doesn't provide the update methods, or implements them to do nothing, or throw exceptions.
  • Refactor the object's API so that it has an read-only interface and a read-write interface, and pass it as an instance of the former. (Of course, the caller can try to cast it to the latter ...)
  • Use Java security to prevent unwanted updates. (This is expensive and complicated ...)

Of course, if the object that you are trying to "protect" has deep structure that you want to prevent changes to, then you need to make sure that you deal with this; e.g. by deep copying, by returning copies of component objects or returning them wrapped, and so on.

Most of the approaches above add complexity and runtime cost, so my advice is to avoid designs where you need to do this kind of thing. If feasible, simply document that the object should be treated as read-only, and leave it to the common sense of the person who codes the method to do the right thing.

For example, it is a well known fact that you should not change the state of an object used as a key in a Map in such a way that its value changes. However, it is common to do nothing to try to "enforce" this; i.e. to use mutable objects as keys ... and just not change them.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.