0

I have RangeTreeIndex and RangeTreeNode class which I'm using to build the index and after inserting 2500 records, after that, I'm trying to save RangeTreeIndex object in the file where I'm receiving StackOverflowError, below is my entire code:

public class RangeTreeNode<T> implements Serializable {
    private static final long serialVersionUID = -1;

    public T key;
    public Object data;
    public RangeTreeNode<T> left;
    public RangeTreeNode<T> right;

    public RangeTreeNode() {
    }
}

public class RangeTreeIndex implements Serializable {

    private RangeTreeNode<Number> root;
    private RangeTreeNode<Number> firstLeafNode;
    private RangeTreeNode<Number> lastLeafNode;
    private Number min;
    private Number max;

    public RangeTreeIndex() {
    }

    @Override
    public int insert(Number key, Object values) {
        Number newKey = new Double(key.doubleValue());

        if (newKey.doubleValue() < min.doubleValue()) {
            min = new Double(key.doubleValue());
        }
        if (newKey.doubleValue() > max.doubleValue()) {
            max = new Double(key.doubleValue());
        }

        RangeTreeNode<Number> newNode = new RangeTreeNode<>(newKey, values);
        this.root = this.insert(root, newNode);

        if (firstLeafNode == null && lastLeafNode == null) {
            firstLeafNode = newNode;
            lastLeafNode = newNode;
        } else if (newNode.key.doubleValue() < firstLeafNode.key.doubleValue()) {
            firstLeafNode = newNode;
        } else if (newNode.key.doubleValue() > lastLeafNode.key.doubleValue()) {
            lastLeafNode = newNode;
        }

        return 1;
    }

    private RangeTreeNode<Number> insert(RangeTreeNode<Number> parentNode, RangeTreeNode<Number> newNode) {
        if (parentNode == null) {
            parentNode = newNode;
        } else {
            if (newNode.key.doubleValue() <= parentNode.key.doubleValue()) {
                parentNode.left = insert(parentNode.left, newNode);
            } else {
                parentNode.right = insert(parentNode.right, newNode);
            }
        }

        return parentNode;
    }
}

public class Main {
    public static void main(String args[]) throws IOException {
        String filePath = "XYZ.jobject";
        try (RandomAccessFile raf = new RandomAccessFile(filePath, "rw");
             FileOutputStream fOut = new FileOutputStream(raf.getFD());
             BufferedOutputStream bos = new BufferedOutputStream(fOut);
             ObjectOutputStream oOut = new ObjectOutputStream(bos)) {
            oOut.writeObject(preferenceIndex);
        }
    }
}

Below is the exception I'm receiving:

Exception in thread "Thread-5" java.lang.StackOverflowError
    at java.lang.Double.doubleToLongBits(Double.java:836)
    at java.io.Bits.putDouble(Bits.java:121)
    at java.io.ObjectStreamClass$FieldReflector.getPrimFieldValues(ObjectStreamClass.java:2168)
    at java.io.ObjectStreamClass.getPrimFieldValues(ObjectStreamClass.java:1389)
    at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1533)
    at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
    at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
    at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
    at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
    at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
    ...
    ...
    ...
    ...

Even if I'm using Apache commons-lang library class SerializationUtils.serialize with passing only a serializable object it throws the same error.

Can anyone faced this problem like that with primitive values?

Yougeshwar Khatri
  • 324
  • 5
  • 21
  • 1
    The primitive values is a red herring. When the stack is exhausted, *any* subsequent method invocation may hit the end, without being responsible itself. The problem is not the deepmost method invocation processing a `double`, the problem are the thousands method invocations already on the stack. Unfortunately, serialization is known for high stack consumption. One thing to check, is whether the tree is *balanced*. Unbalanced trees may cause performance problems at other place too. – Holger Nov 22 '19 at 08:56
  • Thanks for the answer, the tree is not balanced, but I think I have found one glitch is that I should create a list to store the data of the same key, rather than placing again into the left node. – Yougeshwar Khatri Nov 22 '19 at 12:21

0 Answers0