当前位置：首页 > Java

java如何精确π

2026-03-20 07:22:18Java

计算π的精确值方法

在Java中计算π的精确值可以通过多种数学方法实现，以下介绍几种常见的方法及其代码实现。

莱布尼茨级数法

莱布尼茨级数是一个无限级数，可以用来近似计算π的值： [ \pi = 4 \times \left(1 - \frac{1}{3} + \frac{1}{5} - \frac{1}{7} + \frac{1}{9} - \cdots \right) ]

public class LeibnizPi {
    public static double calculatePi(int iterations) {
        double pi = 0.0;
        for (int i = 0; i < iterations; i++) {
            double term = (i % 2 == 0) ? 1.0 : -1.0;
            pi += term / (2 * i + 1);
        }
        return 4 * pi;
    }

    public static void main(String[] args) {
        int iterations = 1000000;
        System.out.println("π的近似值: " + calculatePi(iterations));
    }
}

蒙特卡罗方法

蒙特卡罗方法通过随机采样来估算π的值：

在一个单位正方形内随机生成点。
计算落在单位圆内的点的比例。
比例乘以4即为π的近似值。

import java.util.Random;

public class MonteCarloPi {
    public static double calculatePi(int samples) {
        Random random = new Random();
        int insideCircle = 0;
        for (int i = 0; i < samples; i++) {
            double x = random.nextDouble();
            double y = random.nextDouble();
            if (x * x + y * y <= 1) {
                insideCircle++;
            }
        }
        return 4.0 * insideCircle / samples;
    }

    public static void main(String[] args) {
        int samples = 1000000;
        System.out.println("π的近似值: " + calculatePi(samples));
    }
}

马青公式

马青公式是一种高效的π计算方法，收敛速度较快： [ \pi = 16 \arctan\left(\frac{1}{5}\right) - 4 \arctan\left(\frac{1}{239}\right) ]

public class MachinPi {
    public static double arctan(double x, int terms) {
        double result = 0.0;
        for (int i = 0; i < terms; i++) {
            int exponent = 2 * i + 1;
            double term = Math.pow(x, exponent) / exponent;
            if (i % 2 == 0) {
                result += term;
            } else {
                result -= term;
            }
        }
        return result;
    }

    public static double calculatePi(int terms) {
        return 16 * arctan(1.0 / 5, terms) - 4 * arctan(1.0 / 239, terms);
    }

    public static void main(String[] args) {
        int terms = 100;
        System.out.println("π的近似值: " + calculatePi(terms));
    }
}

使用BigDecimal提高精度

如果需要更高精度的π值，可以使用BigDecimal类：

java如何精确π

import java.math.BigDecimal;
import java.math.MathContext;

public class HighPrecisionPi {
    public static BigDecimal calculatePi(int precision) {
        MathContext mc = new MathContext(precision);
        BigDecimal pi = BigDecimal.ZERO;
        for (int i = 0; i < precision; i++) {
            BigDecimal term = BigDecimal.ONE.divide(
                new BigDecimal(2 * i + 1), mc
            );
            if (i % 2 == 0) {
                pi = pi.add(term);
            } else {
                pi = pi.subtract(term);
            }
        }
        return pi.multiply(new BigDecimal(4));
    }

    public static void main(String[] args) {
        int precision = 100;
        System.out.println("π的近似值: " + calculatePi(precision));
    }
}