Stack Overflow Exception

Question

Hi all,
I am trying to serialize a directed graph. I have Node objects, and each Node object has a Vector of Node objects as one of its fields. The directed graph is stored as a Vector of Node Objects. The Node object and the DirectedGraph objects are structured as follows:
public class Node
private int nodeID;
private Vector adjacentNodes;
// Constructor..
// Some more methods
public class DirectedGraph
private Vector nodes;
// Other fields and methods.
When the no of nodes is very large (~ 10000), I get a StackOverflow error, which I think is because of the recursive serialization. I do not get the exception for a small set of nodes (~1000).
I did read someplace that if the stack depth is greater than 2000, the VM throws the exception.
Are there any workarounds for this (without any changes to the data representation) ?
Are there other custom serializers which detect infinite cycles ?
Or, (worst case), do I have to write my own serializer?
Suggestions, links, will surely help.
Thank you,
Astranomina

Answer 1

As mentioned above, Java serialization handles a cyclic object graph by writing a representation of the object reference to the stream for subsequent occurrances, so this does not cause infinite recursion.
However, if your structure has 25,000 levels then I'm not surprised that you got StackOverflow and for something this size I don't think that trying to increase the stack size is the way to go.
As intimated by Ernimril, a better approach would be to devise a serialized form that is more sympathetic to the environment. I would recommend that you program to interface and use object replacements. That way, the issues regarding serialization can be hidden and coded in the appropriate place:
public interface DirectedGraph
public interface Node
public class LocalDirectedGraph implements DirectedGraph
// your current code (and the same for LocalNode)
Object writeReplace() throws ObjectStreamException
  // flatten structure
  return SerializedDirectedGraph
public class SerializedDirectedGraph implements DirectedGraph
  // a flat structure that can be used to rebuild the hierarchical one
Object readResolve() throws ObjectStreamException;
  // rebuild hierarchy
  return LocalDirectedGraph
}Perhaps traverse the original graph and write a linear structure of the individual objects and some info about what level they are at. Implement writeReplace and place this code in it, returning a SerializedDirectedGraph. At the receiving end implement readResolve and reconstruct the original, returning a LocalDirectedGraph. Everywhere else in your code refer to your objects by the interfaces. Because the JDK handles the cyclic references thing you still get the original object graph, you are just intervening to make the structure more serialization-friendly.
Check out [url http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/output.html#wp5324]this section of the serialization spec. I've used this feature for different reasons, as well as other hooks available in Serialization, and am very impressed with the whole implementation.