java.lang.Math 是 Java 标准库中一个非常重要的工具类，提供了大量用于执行基本数学运算的静态方法。它封装了常见的数学函数，如三角函数、对数、指数、幂运算、取整、最大最小值等，无需实例化即可直接调用。

一、核心概念

Math 类位于 java.lang 包中，无需导入即可使用。

1. 静态工具类

  • 所有方法均为 static，直接通过 Math.方法名() 调用。
  • 构造器为私有（private），不能被实例化。

2. 常量

Math.E     // 自然对数的底，e ≈ 2.71828
Math.PI    // 圆周率，π ≈ 3.14159

3. 方法分类

类别 示例方法
基本运算 abs, max, min, signum
指数与对数 pow, exp, log, log10
三角函数 sin, cos, tan, asin, acos, atan
取整与舍入 ceil, floor, round, rint
随机数 random()
其他 sqrt, cbrt, hypot, toRadians, toDegrees

二、操作步骤（非常详细）

✅ 步骤 1：引入 Math 类（可选）

虽然 java.lang.Math 会自动导入，但显式导入更清晰：

import java.lang.Math;

✅ 步骤 2：使用常量

double e = Math.E;
double pi = Math.PI;
System.out.println("e = " + e);     // 输出: 2.718281828459045
System.out.println("pi = " + pi);   // 输出: 3.141592653589793

✅ 步骤 3：基本数值操作

3.1 绝对值 abs()

int a = -5;
double b = -3.14;

int absA = Math.abs(a);     // 返回 5
double absB = Math.abs(b);  // 返回 3.14

3.2 最大值/最小值 max(), min()

int max = Math.max(10, 20);     // 返回 20
double min = Math.min(1.5, 2.3); // 返回 1.5

3.3 符号函数 signum()

double x = -4.5;
double y = 0;
double z = 3.2;

System.out.println(Math.signum(x)); // -1.0
System.out.println(Math.signum(y)); // 0.0
System.out.println(Math.signum(z)); // 1.0

✅ 步骤 4：指数与对数运算

4.1 幂运算 pow(base, exponent)

double result = Math.pow(2, 3); // 2^3 = 8.0

4.2 指数函数 exp(x)（e^x）

double exp = Math.exp(1); // e^1 ≈ 2.718

4.3 自然对数 log(x)（ln x）

double ln = Math.log(Math.E); // ln(e) = 1.0

4.4 常用对数 log10(x)（log₁₀ x）

double log10 = Math.log10(100); // log₁₀(100) = 2.0

✅ 步骤 5：三角函数（角度需转为弧度）

5.1 角度与弧度转换

double degrees = 90;
double radians = Math.toRadians(degrees); // 转弧度
double back = Math.toDegrees(radians);    // 转回角度

5.2 三角函数计算

double angleRad = Math.toRadians(30); // 30度转弧度
double sin = Math.sin(angleRad);      // sin(30°) = 0.5
double cos = Math.cos(angleRad);      // cos(30°) ≈ 0.866
double tan = Math.tan(angleRad);      // tan(30°) ≈ 0.577

5.3 反三角函数

double asin = Math.asin(0.5);        // 返回弧度 ≈ π/6
double acos = Math.acos(0.5);
double atan = Math.atan(1.0);

✅ 步骤 6：取整与舍入

6.1 向上取整 ceil()

double x = 3.14;
double ceil = Math.ceil(x); // 4.0

6.2 向下取整 floor()

double floor = Math.floor(x); // 3.0

6.3 四舍五入 round()

long rounded = Math.round(3.6); // 返回 long: 4
// 注意：float 用 Math.round(float) 返回 int

6.4 最接近整数 rint()

double rint = Math.rint(3.5); // 返回 4.0（遵循 IEEE 舍入规则）

✅ 步骤 7：开方与距离

7.1 平方根 sqrt()

double sqrt = Math.sqrt(16); // 4.0

7.2 立方根 cbrt()

double cbrt = Math.cbrt(27); // 3.0

7.3 斜边长度 hypot(x, y)

避免中间溢出计算 sqrt(x² + y²)

double hyp = Math.hypot(3, 4); // sqrt(9+16)=5.0

✅ 步骤 8：生成随机数 random()

// 生成 [0.0, 1.0) 之间的 double 值
double rand = Math.random();

// 生成 [min, max) 之间的整数
int min = 1, max = 10;
int randomInt = (int)(Math.random() * (max - min)) + min;

三、常见错误

错误 说明 修正
Math.abs(Integer.MIN_VALUE) 结果仍是负数（溢出） 使用 Math.abs((long) Integer.MIN_VALUE)
三角函数传入角度而非弧度 计算错误 使用 Math.toRadians() 转换
Math.round(float) 返回 int 类型错误 注意返回类型差异
忽略 NaN 和无穷大 导致后续计算异常 使用 Double.isNaN() 检查
Math.pow(0, 0) 返回 1.0（数学上未定义） 根据业务需求处理

四、注意事项

  1. 精度问题：浮点数计算存在精度误差，避免直接比较 ==，应使用误差范围（如 1e-9）。
  2. 类型匹配：注意 int 与 long、float 与 double 的重载方法。
  3. 边界值处理：
    • Math.sqrt(-1) 返回 NaN
    • Math.log(0) 返回 -Infinity
    • Math.log(-1) 返回 NaN
  4. 性能考虑：频繁调用 Math.pow(2, n) 不如位运算 1 << n 高效。
  5. 线程安全：Math 类是无状态的，所有方法线程安全。

五、使用技巧

1. 快速取整

int n = (int) Math.floor(x); // 强制类型转换等价于 floor（正数）

2. 限制数值范围（clamp）

double clamped = Math.max(min, Math.min(max, value));

3. 计算对数换底公式

// log_b(a) = ln(a) / ln(b)
double logBase2 = Math.log(x) / Math.log(2);

4. 生成指定范围随机数

// [a, b] 闭区间
int rand = (int)(Math.random() * (b - a + 1)) + a;

六、最佳实践与性能优化

实践 说明
✅ 优先使用 Math 而非手动实现 更可靠、优化过
✅ 使用 StrictMath 替代 Math？ 仅当需要跨平台严格一致性（性能略低）
✅ 避免重复计算常量 如 Math.PI / 180 可缓存
✅ 用位运算替代 pow(2, n) 1 << n 比 Math.pow(2, n) 快得多
✅ 大量随机数使用 java.util.Random Math.random() 内部使用 synchronized，高并发下性能较差
✅ 使用 Math.hypot() 防溢出 比手动 sqrt(x*x + y*y) 更安全
✅ 对频繁调用的方法做缓存 如预计算三角函数表（特定场景）

七、完整示例代码

public class MathDemo {
    public static void main(String[] args) {
        // 常量
        System.out.println("E = " + Math.E);
        System.out.println("PI = " + Math.PI);

        // 基本运算
        System.out.println("abs(-5) = " + Math.abs(-5));
        System.out.println("max(3,7) = " + Math.max(3, 7));

        // 幂与开方
        System.out.println("2^3 = " + Math.pow(2, 3));
        System.out.println("√16 = " + Math.sqrt(16));

        // 三角函数
        double angle = Math.toRadians(60);
        System.out.println("sin(60°) = " + Math.sin(angle));

        // 随机数
        int rand = (int)(Math.random() * 100);
        System.out.println("Random [0,99]: " + rand);

        // 取整
        System.out.println("ceil(3.2) = " + Math.ceil(3.2));
        System.out.println("round(3.6) = " + Math.round(3.6));
    }
}

总结

Math 类是 Java 中进行数学计算的基石。掌握其核心方法、避免常见错误、遵循最佳实践，能显著提升代码的正确性与性能。对于高性能或特殊需求场景，可结合 StrictMath 或 java.util.Random 等类进行优化。

💡 提示：在实际开发中，建议将常用数学计算封装成工具类，提高复用性和可维护性。