Re: Cloning and Distinct Copies of Objects
Hal Vaughan wrote On 08/15/06 12:55,:
[...]
If I understand all this correctly, then if I want to duplicate a String[]
function, I need to do something like this:
String[] oldCopy = { "Duke", "rulez!" };
String[] newCopy = new String[oldCopy.length];
int i;
for (i = 1; i < oldCopy.length; i++) {
ITYM 0 instead of 1 here.
newCopy[i] = oldCopy[i].clone();
This won't work for at least three reasons, one of them
fixable and the other two inescapable (to the best of my
knowledge).
The fixable problem is that clone() returns an Object
reference but you need a String reference, so the statement
won't compile. You could add a (String) cast to solve that
problem; the compiler would insert code to do a run-time check
that the Object is in truth a String, and then either allow
the assignment or throw ClassCastException.
The first inescapable problem is that the clone() method
of String is protected, meaning that it's accessible only
from within the String class itself, from within other classes
of the java.lang package, or from subclasses of String. Since
your code is not part of String nor part of java.lang, and
since String is final and can have no subclasses, your code
cannot call String's clone() method.
The second inescapable problem is that even if you somehow
managed to call clone() on a String, you would find that the
String class does not implement the Cloneable interface. The
clone() method (whose implementation String inherits from
Object) will just throw a CloneNotSupportedException and
snicker at you behind your back.
The upshot: You can't clone a String -- and String is not
unique in being non-cloneable, either.
[...] Since I can create a new array that will still reference the
old strings, it seems that the only way to create a complete copy as it is,
as an independent object to save the exact state of oldCopy is to clone
each String individually.
You could *copy* (not *clone*) the String objects by using
String's copy constructor, or by a few other routes. But it's
a dumb thing to do: Why do you think you need all those copies?
Keep in mind that a String is immutable; once it's been created
its content cannot change. If the String eventually expires,
it will have its original value right up to the instant when
the garbage collector swings its scythe. (Well, somebody once
posted a horrible hack that showed how a String could in fact
be changed -- but if *that* sort of mischief is afoot in your
JVM, you might as well throw in the towel.)
Do you clone yourself when you tell someone your name? Do
you give away cloned copies, or do you let the other people
access the one and only You through a reference?
--
Eric.Sosman@sun.com