how does java deep copy utility reserve objects' inner relationships?

I was using apache SerializationUtils to deep copy objects and found something amazing. For example, Object A has 2 member B1,B2, and both of them has the same member C (refering to same object).
After deep copy, A' was created , and I was expecting B1' has member C1', B2' has member C2'. But it occurs that both B1' and B2' has the same member C'.

It seems that after deep copy, the object hierarchy and relationship is maintained. How is that implemented?

I don't know the Apache library, but most probably it keeps a map of instances copied so far. And if it encounters an instance C to be copied, it first checks whether there already exists a copy C' of that instance. If so, it uses the existing copy. If not, it creates a deep copy of C, giving C' and stores that copy in the map.

One fine point to consider: I guess that Apache bases the existence test on the on the == operator and not the equals() method, as the == operator will give the cleanest result, best resembling the original references structure. If not, two distinct instances C1 and C2 that just happen to satisfy the equals() test would end up as a single copy C'.

Let's consider two references as having 'the same identity' if they are pointing to the same object. That is, given:

Object a = ...;
Object b = ...;

Then a and b are 'identical' if this holds: a == b, which will only hold if they point at the same object.

Note that a.equals(b) is different; any two references for which that holds can be considered 'equal', but 2 objects may be involved. Trivial example:

String a = new String("Hello");
String b = new String("Hello");
a == b; // this is false
a.equals(b); // this is true

It is possible to figure out if 2 references are identical and not just equal.

One easy check is literally what I just showed you: ==, which checks identical and not equal.

Most likely, the code in SerializationUnits uses WeakHashMap which is a map that maps on identity (more or less, 'the pointer'). WHM is mostly an internal implementation, but note that you can always get the identity hashcode via System.identityHashCode which returns the same value for the same object, even if that object is mutated. In theory, a.hashCode() can return a different value (and for mutable objects, it tends to), but System.identityHashCode(a) is the same value for any given instance for the lifetime of a VM.

Plain jane HashMap uses a.hashCode() to know which bucket to look at, and then a.equals(b) to scan for equality.

A WeakHashMap uses System.identityHashCode(a) to know which bucket to look at, and then a == b to scan for equality.

Armed with that, writing a serializer that preserves hierarchy and relationship is then trivial.

Note also that without such a mechanism, solid serialization is impossible. After all, imagine this structure:

List<Object> list = new ArrayList<Object>();
list.add(list); // ooooh, recursion!

without tools like WeakHashMap, any attempt to serialize this construct will result in a StackOverflowError, for obvious reasons.