下面是一个递归算法的例子，用于反转单链表。在笔记本电脑(规格为4gb内存，Intel Core i5 2.3 GHz CPU 64位，Windows 7)上，对于大小接近10,000的链表，该函数将遇到StackOverflow错误。

我的观点是，我们应该明智地使用递归，始终考虑到系统的规模。

通常递归可以转换为迭代程序，迭代程序的伸缩性更好。(本页底部给出了同一算法的一个迭代版本。它在9毫秒内反转大小为100万的单链表。)

private static LinkedListNode doReverseRecursively(LinkedListNode x, LinkedListNode first){

    LinkedListNode second = first.next;

    first.next = x;

    if(second != null){
        return doReverseRecursively(first, second);
    }else{
        return first;
    }
}


public static LinkedListNode reverseRecursively(LinkedListNode head){
    return doReverseRecursively(null, head);
}

同一算法的迭代版本:

public static LinkedListNode reverseIteratively(LinkedListNode head){
    return doReverseIteratively(null, head);
}


private static LinkedListNode doReverseIteratively(LinkedListNode x, LinkedListNode first) {

    while (first != null) {
        LinkedListNode second = first.next;
        first.next = x;
        x = first;

        if (second == null) {
            break;
        } else {
            first = second;
        }
    }
    return first;
}


public static LinkedListNode reverseIteratively(LinkedListNode head){
    return doReverseIteratively(null, head);
}

这个问题的很多答案都是好的。但是，我想采取稍微不同的方法，并对内存的工作原理和(简化的)可视化更好地理解StackOverflow错误给出一些更深入的见解。这种理解不仅适用于Java，而且适用于所有进程。

在现代系统中，所有新进程都有自己的虚拟地址空间(VAS)。从本质上讲，VAS是操作系统在物理内存之上提供的抽象层，目的是确保进程之间不相互干扰内存。内核的任务是将虚拟地址映射到实际的物理地址。

VAS可以分为几个部分:

为了让CPU知道它应该做什么，机器指令必须加载到内存中。这通常被称为代码或文本段，具有静态大小。

在此之上，可以找到数据段和堆。数据段大小固定，包含全局变量或静态变量。 当程序遇到特殊情况时，它可能需要额外分配数据，这就是堆发挥作用的地方，因此它能够动态地增长大小。

堆栈位于虚拟地址空间的另一侧，并使用后进先出(LIFO)数据结构跟踪所有函数调用。与堆类似，程序在运行时可能需要额外的空间来跟踪正在调用的新函数调用。由于堆栈位于VAS的另一侧，它正向相反的方向增长，即朝着堆的方向增长。

博士TL;

这就是StackOverflow错误发挥作用的地方。

由于堆栈向下增长(朝向堆)，可能会发生在某个时间点它不能继续增长，因为它会与堆地址空间重叠。一旦发生这种情况，就会发生StackOverflow错误。

发生这种情况最常见的原因是由于程序中的一个错误导致递归调用不能正确终止。

请注意，在某些系统上，VAS的行为可能略有不同，甚至可以分为更多的部分，但是，这种一般理解适用于所有UNIX系统。

下面是一个递归算法的例子，用于反转单链表。在笔记本电脑(规格为4gb内存，Intel Core i5 2.3 GHz CPU 64位，Windows 7)上，对于大小接近10,000的链表，该函数将遇到StackOverflow错误。

我的观点是，我们应该明智地使用递归，始终考虑到系统的规模。

通常递归可以转换为迭代程序，迭代程序的伸缩性更好。(本页底部给出了同一算法的一个迭代版本。它在9毫秒内反转大小为100万的单链表。)

private static LinkedListNode doReverseRecursively(LinkedListNode x, LinkedListNode first){

    LinkedListNode second = first.next;

    first.next = x;

    if(second != null){
        return doReverseRecursively(first, second);
    }else{
        return first;
    }
}


public static LinkedListNode reverseRecursively(LinkedListNode head){
    return doReverseRecursively(null, head);
}

同一算法的迭代版本:

public static LinkedListNode reverseIteratively(LinkedListNode head){
    return doReverseIteratively(null, head);
}


private static LinkedListNode doReverseIteratively(LinkedListNode x, LinkedListNode first) {

    while (first != null) {
        LinkedListNode second = first.next;
        first.next = x;
        x = first;

        if (second == null) {
            break;
        } else {
            first = second;
        }
    }
    return first;
}


public static LinkedListNode reverseIteratively(LinkedListNode head){
    return doReverseIteratively(null, head);
}

堆栈溢出的意思就是:堆栈溢出。通常在程序中有一个堆栈，它包含局部作用域变量和例程执行结束时返回的地址。该堆栈往往是内存中的某个固定内存范围，因此它可以包含多少值是有限的。

如果堆栈是空的，你不能弹出，如果你这样做，你会得到堆栈溢出错误。

如果堆栈满了，你就不能推，如果你推了，你就会得到堆栈溢出错误。

当你在堆栈中分配了太多内存时，就会出现堆栈溢出。例如，在前面提到的递归中。

有些实现优化了某些形式的递归。特别是尾递归。尾递归例程是一种例程，其中递归调用作为例程所做的最后一件事出现。这样的例行调用被简化为跳转。

有些实现甚至实现了自己的递归堆栈，因此它们允许递归继续进行，直到系统内存耗尽。

你可以尝试的最简单的事情就是如果可以的话增加你的堆栈大小。如果不能这样做，那么第二种方法是查看是否有什么东西明显导致堆栈溢出。试着在调用前后打印一些东西到例程中。这可以帮助您找到失败的例程。

StackOverflowError是Java中的运行时错误。

当超过JVM分配的调用堆栈内存量时抛出该异常。

抛出StackOverflowError的一种常见情况是由于过度深度递归或无限递归而导致调用堆栈超出。

例子:

public class Factorial {
    public static int factorial(int n){
        if(n == 1){
            return 1;
        }
        else{
            return n * factorial(n-1);
        }
    }

    public static void main(String[] args){
         System.out.println("Main method started");
        int result = Factorial.factorial(-1);
        System.out.println("Factorial ==>"+result);
        System.out.println("Main method ended");
    }
}

堆栈跟踪:

Main method started
Exception in thread "main" java.lang.StackOverflowError
at com.program.stackoverflow.Factorial.factorial(Factorial.java:9)
at com.program.stackoverflow.Factorial.factorial(Factorial.java:9)
at com.program.stackoverflow.Factorial.factorial(Factorial.java:9)

在上述情况下，可以通过进行编程更改来避免这种情况。 但如果程序逻辑是正确的，它仍然发生，那么你的堆栈大小需要增加。

这里有一个例子

public static void main(String[] args) {
    System.out.println(add5(1));
}

public static int add5(int a) {
    return add5(a) + 5;
}

一个StackOverflowError基本上是当你试图做一些事情，最有可能调用自己，并一直到无穷大(或直到它给出一个StackOverflowError)。

Add5 (a)将调用自身，然后再次调用自身，依此类推。