Thank you for pointing that out to me. So you're actually saying there
is no really no proper way to clone a HashSet?

Actually, you could create a new HastSet and copy each item from the old
HashSet to the new one. Granted, it's not as fast as 'cloning' it, but
it should work.

Thanks Tony,

I have written a simple sample below, but from the sample's output, I have
found out that it seems that the clone method of Hashtable copies the the
content of both keys and values, not as mentioned in the Java API
specification of clone method of class Hashtable "but the keys and values
are not cloned".

Do you know what points do the Java specification mean?

[Code]
        Hashtable table1 = new Hashtable();
        table1.put ("key1", "value1");
        Hashtable table2 = (Hashtable) table1.clone();
        if (table2.containsKey ("key1"))
        {
            System.out.println ("Contains!");
            table2.put ("key1", "value2");
            String newValue1 = (String) table1.get ("key1");
            System.out.println ("New value1 of table1: " + newValue1);
            newValue1 = (String) table2.get ("key1");
            System.out.println ("New value1 of table2: " + newValue1);
        }
        else
        {
            System.out.println ("Not contains!");
        }
[/Code]

Output is:

Contains!
New value1 of table1: value1
New value1 of table2: value2

regards,
George

No. You get a serialization (first half of total copy) only when you
explicitly write data to a serialized-object stream.
 http://java.sun.com/j2se/1.3/docs/api/java/io/ObjectOutputStream.html
Then the second half of the totally-deep copy operation occurs when the
stream is used to reconstitute an object in a new location:
 http://java.sun.com/j2se/1.3/docs/api/java/io/ObjectInputStream.html

The reason why stack overflow is *sure* to happen if you try to use a
naive recursive algorithm to copy a structure that contains a
pointer-loop is that you recurse deeper and deeper to keep encountering
that same loop over and over and over, never finding any bottom to the
structure so never returning from recursion. For example, imagine a
simple structure with two nodes, each of which points to the other:
 A <==> B
So you start at A, copy that, see pointer to B so you recurse into B to
copy that, and see pointer to A and recurse into that to copy A, and
see pointer to B but fail to notice you already followed that pointer
so you recurse into B again, etc. back and forth deeper and deeper
until the stack overflows. At some point you've copied:
 A -> B -> A1 -> B1 -> A2 -> B2 -> A3 -. B3 -> ...
many copies of each node and each direction of link, when stack
overflows.

If you keep a list of all nodes already visited, and never copy the
same node more than once, and never copy the same link more than once,
it works like this: Start at A, put A into table, see link to B, copy
link, see B is new node, put B into table, copy B, see link to A, copy
link, see A already in table, back off recursion to B, see no more
links from B, back off to A, see no more links from A, back out of top
level of recursion.

The only way such a table-keeping algorithm can get stack overflow is
if you really do have a very very very long chain of links, which
wouldn't happen in any reasonable program except if you make a linked
list to hold a very large list which is possibly unreasonable in the
first place. Instead of a very very very long linked list, it's
probably better to keep the data in a balanced binary tree of some
sort, so then a list of n elements requires only log(n) stack depth to
copy it all. For example, see:
 http://java.sun.com/j2se/1.3/docs/api/java/util/TreeSet.html
 http://java.sun.com/j2se/1.3/docs/api/java/util/TreeMap.html