1. 牛顿-莱布尼茨公式（积分法）

牛顿-莱布尼茨公式是微积分学中的一个基本定理，它可以将定积分转换为求和问题。在计算π时，我们可以通过计算半圆的面积来逼近π的值。

public static double calculatePiUsingIntegration() { final double precision = 1e-15; double sum = 0; double term = 1.0; int i = 0; while (Math.abs(term) > precision) { term = (-1) * term * (2 * i) / (2 * i + 1); sum += term; i++; } return 4 * sum; } 

这种方法适用于精度要求不高的情况，计算速度相对较慢。

2. 阿基米德方法

阿基米德方法通过计算多边形内切圆和外接圆的周长来逼近π的值。随着多边形边数的增加，逼近的精度会越来越高。

public static double calculatePiUsingArchimedes() { final int nSides = 1000000; double sideLength = 1.0 / nSides; double perimeter = nSides * sideLength; double area = (perimeter * sideLength) / 2; return 4 * area; } 

这种方法计算速度较快，但精度取决于多边形的边数。

3. 高斯-勒让德算法

高斯-勒让德算法是一种高效的计算π的数值方法，其原理是基于三角函数的性质。该方法通过迭代计算，每次迭代都能将π的近似值提高一个数量级。

public static double calculatePiUsingGaussLegendre() { final double a = 1.0; final double b = 1.0; final double c = Math.sqrt(2.0); double p = a * a + b * b; double q = 2.0 * a * b; double m = c * c - p; double t = p; for (int k = 1; k <= 1000; k++) { p = q; q = 2.0 * (c * p - m); m = t; t = p; } return 2.0 * m / t; } 

这种方法计算速度较快，且精度较高。

4. BBP算法

BBP算法是一种快速计算π的任意位数的方法，其特点是不需要先计算前面的位数。该算法基于π的级数展开式，通过迭代计算各个位数。

public static double calculatePiUsingBBP(int digits) { double pi = 0.0; for (int i = 0; i < digits; i++) { pi += (1.0 / (16.0 * i + 1)) * Math.pow(-1, i); } pi *= 4.0; return pi; } 

这种方法计算速度非常快，但计算精度受限于输入参数。

5. Chudnovsky算法

Chudnovsky算法是一种非常高效的计算π的方法，其收敛速度非常快。该算法基于π的级数展开式，通过迭代计算各个位数。

public static double calculatePiUsingChudnovsky() { final int iterations = 1000000; double[] c = new double[iterations + 1]; c[0] = 426880 * Math.sqrt(10005); for (int i = 1; i <= iterations; i++) { c[i] = c[i - 1] * 13591409 + 545140134; } double pi = Math.sqrt(10005) * c[iterations] / (13591409 * iterations * iterations * iterations * iterations); return pi; } 

这种方法计算速度非常快，且精度非常高。

以上是Java中计算π的5种方法，每种方法都有其优缺点。在实际应用中，可以根据需求选择合适的方法。