How to ignore StackOverFlow error in Java?

I know why it gives the error, I don't want to correct it I want the system to ignore it and keep running.
I know that the recursion is not infinite and I need to know when it will stop although I am sure it will be in a very large number and after a good while of execution.

Thankssss.

public static int fun1(int begin, int end, int cont) {
    if (begin >= end) {
        return 1;
    }
    cont += fun1(begin, (begin + end) / 2, cont);
    cont += fun1(begin + (end - begin) / 4, begin + 3 * (end - begin) / 4, cont);
    cont += fun1((begin + end) / 2, end, cont);
    return cont;
}

>I know that the recursion is not infinite

You "know" a falsehood.

public static int fun1(int begin, int end, int cont) {
    if (begin >= end) {
        return 1;
    }
    cont += fun1(begin, (begin + end) / 2, cont);
    cont += fun1(begin + (end - begin) / 4, begin + 3 * (end - begin) / 4, cont);
    cont += fun1((begin + end) / 2, end, cont);
    return cont;
}

Consider what happens if we call fun1(0, 1, 0).

Is begin >= end? No; begin == 0 and end == 1. So we recurse.

What are the arguments for our recursive calls? (begin + end) / 2 is equal to (0 + 1) / 2 is equal to 1 / 2 is equal to 0, with integer division. So the first recursive call is fun1(0, 0, 0).

But the last recursive call is fun1(0, 1, 0). Wait. That looks familiar, yeah? (Never mind the middle one; we have already shown a fault.)

@Karl's answer explains why your function is actually infinitely recursive.

But you asked:

> How to ignore StackOverFlow error in Java?

You cannot simply ignore it. If you do that, the program crashes (or a child thread dies, or something) and you don't get an answer.

You could do this:

Integer result = null;
try {
    result = fun1(x, y, z);
} catch (StackOverflowError e) {
    // We are ignoring this
}

if (result == null) {
    System.out.println("cannot compute fun1(x,y,z)");
} else {
    System.out.println("fun1(x,y,z) is " + result);
}

But when you look at this, we are not really ignoring the exception. We are catching it and (ultimately) dealing with it as a special case.

Note that you can get a StackOverflowError even in cases where the recursion is not infinite. For example, if I was to add two numbers using recursion:

public int add(int a, int b):
   if (a < 0 || b < 0) {
       throw new IllegalArgumentException("negative");
   else if (a == 0) {
       return b;
   } else
       return add(a - 1, b + 1);
   }

Since Java (typically) doesn't do tail-call optimization, large enough arguments will give a StackOverflowError.

So what it the solution to StackOverflowErrors in cases where the function is not infinitely recursive?

• One approach would be to use a larger thread stack size. This could be done by using the -Xss<value> option to set the default stacksize for the JVM. Alternatively, you can supply a stack size via the Thread constructor when creating a new thread. However, the maximum practical thread stack size is limited by the amount of available memory, and potentially by JVM, OS and hardware architectural limits.

• A second approach is to translate the recursive function into an iterative form. But note that if you simply simulate the recursive calls using a stack implemented in software, you have to deal with the possibility that that data structure gets too big.

• A third approach is to try and find an algebraic solution; i.e. turn this into a mathematical problem.

But note that there are some cases where none of the above will work. For example, consider the Ackermann function.