堆栈溢出错误（Java）

所以我的代码使用for和while循环和递归方法打印出Pi的估计值。这是所有工作，除了我的编译器说我的递归方法中的if语句有堆栈溢出错误。堆栈溢出错误（Java）

public static final double REAL_PI = 3.14159;//PI is the value Mr.B gave us on the handout 
public static double Pi = 0; //Pi is the value of Pi that this program calculates 
public static int m = 0; 
public static int c = 0; 


public static void main (String [] args) 
{ 
    Algorithm(); //calls on method of calculating pi 
    System.out.println("Calculated pi: " + Pi); //prints out pi 
    countDigits(Pi); //calls on countdigits method 
    System.out.println("Number of digits: " + c); //has the computer print out the count because that's how many digits are the same 
    While(); 
    Recursive(1, 0.0); //calls on estimate digits method 
} 

public static double Algorithm() //should return a double (pi) 
{ 
    for(m=1; m<=100000; m++) 
    { 
     Pi += 4*(Math.pow(-1, m-1)/((2*m)-1));//Math.pow uses math package to calculate a power to use the algorithm 
    } 
    return Pi; 
} 

public static int countDigits (double Pi) 
{ 
    int a = (int) Pi; //the int cast makes Pi and REAL_PI into integers so the program can compare each digit separately 
    int b = (int) REAL_PI; 
    int c = 0; 
    int count = 0; 
    while(a == b)//if m less then or equal to 100,000 then while loop runs 
    { 
     count ++; 
     a = (int) (Pi*(Math.pow(10,count))); //if a=b then the computer will multiply Pi and REAL_PI by 10 
     b = (int) (REAL_PI*(Math.pow(10,count))); 
     /*when you input a and b 
     * while loop compares them 
     * if a = b then loop continues until a doesn't equal b and loop ends 
     */ 
    } 
    c = count; //gives c the value of the count so it can be used outside the method 
    return count; 
} 
public static double While() 
{ 
    int m = 1; 
    Pi = 0.0; 
    while (countDigits(Pi) < 6) 
    { 
     Pi += 4*(Math.pow(-1, m-1)/((2*m)-1)); 
     m++; 
    } 
    Pi = (int)(Pi * 1000000); 
    Pi = (double)(Pi/1000000); 
    System.out.println("Pi using while loop: " + Pi); 
    return Pi; 
} 

public static double Recursive(int m,double Pi) 
{ 
    Pi += 4*(Math.pow(-1, m-1)/((2*m)-1)); 
    if (countDigits(Pi) < 6) 
    { 
     return Pi += Recursive(m+1,Pi); 
    } 
    Pi = (int)(Pi * 1000000); 
    Pi = (double)(Pi/1000000); 
    System.out.println("Pi using recursive: " + Pi); 
    return Pi; 
}

}

来源

2014-10-09 KazuoKatiushi

当达到此限制时，只能在堆栈中进行如此多的方法调用，程序将通过一个运行时错误而不是编译器错误的stackoverflow错误。 – brso05 2014-10-09 19:47:48

您可能想尝试计算pi的更少位数...... – brso05 2014-10-09 19:48:32

另外'c = count;'不能在方法外部使用它，因为还有一个局部变量'c'。 – MrHug 2014-10-09 19:51:24

的问题是，莱布尼兹系列计算π收敛EXTREMELY慢。使用程序中，我发现，经过3663次迭代（当我杀了程序），该值是这样的：

pi=3.141865802997432 
pi=3.1413195787723875 
pi=3.1418656538577117 
pi=3.1413197278306884

不过只有3位小数，并且它会甚至需要很长的时间是准确的到4.堆栈不够大，无法存放这么多的递归调用，最终会溢出。

来源

2014-10-09 19:56:56 ajb

堆栈溢出错误（Java）

回答

相关问题