Java常用API详解
本文将系统讲解Java开发中高频使用的工具类API，涵盖数学计算、系统操作、对象处理和大数运算等场景。ps:本文是免费的,如果被csdn锁了,请联系我.如果需要查看更详细的说明,可以查阅javaAPI帮助文档.我本来想直接把API文档整合到文章中方便大家下载,结果csdn这货直接给锁了,真是
目录
一、Math类：数学工具集
作用：提供基础数学运算的静态方法
特点
常用方法
使用示例
特别说明
二、System类：系统级操作
作用：访问系统资源与控制程序行为
特点
常用方法
使用示例
特别说明
三、Runtime类：运行时环境
作用：与JVM运行时交互
构造实例
常用方法
使用示例
特别说明
四、Object类：所有类的超类
作用：定义对象基础行为
常用方法
使用示例
特别说明
五、Objects工具类：对象操作增强
作用：空安全的对象操作工具
特点
常用方法
使用示例
特别说明
六、BigInteger：超大整数运算
作用：处理超过long范围的整数
构造方法
常用方法
使用示例
特点说明
七、BigDecimal：高精度浮点运算
作用：解决double精度丢失问题
构造方法
常用方法
使用示例
特别说明
一、Math类：数学工具集
作用：提供基础数学运算的静态方法
特点
- 无构造方法（私有化构造，禁止实例化）
- 所有方法均为
static调用
常用方法
| 方法签名 | 作用说明 |
|---|---|
public static int abs(int a) | 获取参数绝对值 |
public static double ceil(double a) | 向上取整（返回≥参数的最小整数） |
public static double floor(double a) | 向下取整（返回≤参数的最大整数） |
public static int round(float a) | 四舍五入取整 |
public static int max(int a, int b) | 获取两个int值的较大值 |
public static double pow(double a, double b) | 计算a的b次幂 |
public static double random() | 生成[0.0,1.0)随机值 |
使用示例
1. 绝对值计算
// 方法签名
public static int abs(int a)// 使用示例
int result = Math.abs(-15);
System.out.println(result); // 输出: 15double dResult = Math.abs(-3.14);
System.out.println(dResult); // 输出: 3.142. 向上取整
// 方法签名
public static double ceil(double a)// 使用示例
double val1 = Math.ceil(3.2);
System.out.println(val1); // 输出: 4.0double val2 = Math.ceil(-2.7);
System.out.println(val2); // 输出: -2.03. 向下取整
// 方法签名
public static double floor(double a)// 使用示例
double val1 = Math.floor(3.8);
System.out.println(val1); // 输出: 3.0double val2 = Math.floor(-2.3);
System.out.println(val2); // 输出: -3.04. 四舍五入
// 方法签名
public static int round(float a)// 使用示例
int r1 = Math.round(3.5f);
System.out.println(r1); // 输出: 4int r2 = Math.round(-2.4f);
System.out.println(r2); // 输出: -25. 最大值比较
// 方法签名
public static int max(int a, int b)// 使用示例
int maxVal = Math.max(25, 30);
System.out.println(maxVal); // 输出: 30double dMax = Math.max(3.14, 2.71);
System.out.println(dMax); // 输出: 3.146. 幂运算
// 方法签名
public static double pow(double a, double b)// 使用示例
double power = Math.pow(2, 5);
System.out.println(power); // 输出: 32.0double root = Math.pow(27, 1.0/3);
System.out.println(root); // 输出: 3.07. 随机数生成
// 方法签名
public static double random()// 使用示例
double rand = Math.random();
System.out.println(rand); // 输出: 如0.7312// 生成1-100随机整数
int dice = (int)(Math.random()*100) + 1;
System.out.println(dice); // 输出: 如57特别说明
- 所有方法均为静态方法，直接通过
Math.方法名()调用 ceil()对负数处理时：Math.ceil(-2.7)→-2.0round()对.5小数统一向上取整：3.5→4，-3.5→-3random()实际使用建议结合范围计算：
// 生成10-99随机数
int num = (int)(Math.random()*90) + 10;二、System类：系统级操作
作用：访问系统资源与控制程序行为
特点
- 无构造方法（私有化构造，禁止实例化）
- 所有方法均为
static调用
常用方法
| 方法签名 | 作用说明 |
|---|---|
public static void exit(int status) | 终止JVM运行 |
public static long currentTimeMillis() | 获取当前时间戳（毫秒值） |
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) | 数组拷贝 |
使用示例
1. 终止虚拟机
// 方法签名
public static void exit(int status)// 使用示例
System.out.println("程序开始执行");
System.exit(0); // 0表示正常退出
System.out.println("这行代码不会执行"); // 非零状态码表示异常终止
System.exit(1);2. 获取时间戳
// 方法签名
public static long currentTimeMillis()// 使用示例
// 计算代码执行时间
long start = System.currentTimeMillis();// 模拟耗时操作
for(int i=0; i<100000; i++){}long end = System.currentTimeMillis();
System.out.println("耗时：" + (end - start) + "ms");// 生成唯一时间戳
String timestamp = String.valueOf(System.currentTimeMillis());3. 数组拷贝
// 方法签名
public static void arraycopy(Object src, // 源数组int srcPos, // 源数组起始位置Object dest, // 目标数组int destPos, // 目标数组起始位置int length // 拷贝元素个数
)// 使用示例
int[] srcArr = {1,2,3,4,5};
int[] destArr = new int[5];// 拷贝前3个元素到目标数组
System.arraycopy(srcArr, 0, destArr, 0, 3);
System.out.println(Arrays.toString(destArr));
// 输出: [1, 2, 3, 0, 0]// 部分覆盖拷贝
System.arraycopy(srcArr, 2, destArr, 1, 2);
System.out.println(Arrays.toString(destArr));
// 输出: [1, 3, 4, 0, 0]特别说明
exit方法状态码
- 0：正常终止
- 非0：异常终止（可自定义错误类型）
arraycopy注意事项
// 需保证目标数组容量充足
int[] smallArr = new int[2];
// 以下代码会抛出ArrayIndexOutOfBoundsException
System.arraycopy(srcArr, 0, smallArr, 0, 3);时间戳精度
currentTimeMillis()精度为毫秒级，
如需更高精度使用System.nanoTime()
三、Runtime类：运行时环境
作用：与JVM运行时交互
构造实例
// 唯一合法的实例获取方式
Runtime runtime = Runtime.getRuntime();常用方法
| 方法签名 | 核心作用 | 返回值说明 |
|---|---|---|
availableProcessors() | 获取CPU可用线程数 | int（如8核16线程返回16） |
maxMemory() | JVM最大可申请内存总量 | long（单位：字节） |
totalMemory() | JVM当前已分配内存大小 | long（单位：字节） |
freeMemory() | JVM剩余可用内存量 | long（单位：字节） |
exec(String command) | 执行操作系统命令 | Process进程对象 |
exit(int status) | 终止JVM运行 | void（0=正常终止） |
使用示例
1. 获取系统资源信息
// 获取CPU线程数
int processors = runtime.availableProcessors();
System.out.println("CPU线程数: " + processors); // 如输出: CPU线程数: 16// 内存换算为MB
long maxMem = runtime.maxMemory() / 1024 / 1024;
long totalMem = runtime.totalMemory() / 1024 / 1024;
long freeMem = runtime.freeMemory() / 1024 / 1024;System.out.println(String.format("最大内存: %dMB 已分配: %dMB 剩余内存: %dMB",maxMem, totalMem, freeMem
));
// 输出示例: 最大内存: 3641MB 已分配: 245MB 剩余内存: 234MB2. 执行系统命令
// 启动记事本程序（Windows系统）
Process process = runtime.exec("notepad.exe");// 等待进程结束（最多等10秒）
boolean exitStatus = process.waitFor(10, TimeUnit.SECONDS);
System.out.println("程序是否正常退出: " + exitStatus);3. 强制终止JVM
// 保存重要数据逻辑
saveCriticalData();// 立即终止程序（状态码0表示正常）
runtime.exit(0); // 后续代码不会执行
System.out.println("此消息不会显示");特别说明
内存单位换算
建议将byte转换为MB提升可读性：
long memoryMB = runtime.maxMemory() / (1024 * 1024);exec()方法安全风险
// 禁止执行用户输入的命令（存在注入风险）
String userInput = "rm -rf /"; // 恶意命令示例
runtime.exec(userInput); // 将导致灾难性后果跨平台命令差异
// Linux/Mac执行命令
Process lsProcess = runtime.exec("ls -l"); // Windows执行命令
Process dirProcess = runtime.exec("cmd /c dir");异常处理规范
try {Process p = runtime.exec("invalid_command");
} catch (IOException e) {System.err.println("命令执行失败: " + e.getMessage());
} ps:有意思的是System中的exit方法调用的就是Runtime中的exit方法
四、Object类：所有类的超类
作用：定义对象基础行为
java.lang.Object类位于金字塔的最顶端，它是所有Java类的终极父类
在Java中，并非所有Object类的方法都需要重写。是否需要重写取决于具体需求
常用方法
| 方法签名 | 图示说明 | 标准实现说明 |
|---|---|---|
public String toString() | 返回对象的字符串表示形式 | ✅ 默认返回类名@哈希值，建议重写 |
public boolean equals(Object obj) | 比较两个对象是否相等 | ✅ 默认比较内存地址，需重写逻辑 |
protected Object clone() | 对象克隆（图示参数错误） | ✅ 无参数，需实现Cloneable接口 |
使用示例
toString()
作用：定义对象的字符串描述
正确实现：
@Override
public String toString() {return "User{name='" + name + "', age=" + age + "}";
}调用示例：
User user = new User("Alice", 25);
System.out.println(user);
// 输出: User{name='Alice', age=25}equals()
作用：自定义对象等价性判断
正确实现：
@Override
public boolean equals(Object o) {// 1. 地址相同直接返回trueif (this == o) return true;// 2. 类型检查if (o == null || getClass() != o.getClass()) return false;// 3. 字段比较User user = (User) o;return age == user.age && Objects.equals(name, user.name);
}配套重写hashCode()：
@Override
public int hashCode() {return Objects.hash(name, age);
}clone()
作用：创建对象的副本
正确实现步骤：
- 实现
Cloneable接口（标记接口） - 重写
clone方法
public class User implements Cloneable {@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}使用示例：
User original = new User("Bob", 30);
User copy = (User) original.clone();特别说明
深拷贝与浅拷贝
默认clone()为浅拷贝，需手动实现深拷贝：
@Override
protected Object clone() throws CloneNotSupportedException {User cloned = (User) super.clone();cloned.details = this.details.clone(); // 引用类型字段单独处理return cloned;
} equals()与hashCode()必须同步重写
确保在HashMap/HashSet等集合中正常工作
慎用clone()
推荐使用拷贝构造器或工厂方法代替
关于标记接口,是一种不包含任何方法的特殊接口，它通过类型信息向JVM或框架传递特定语义。这种设计模式的核心作用是通过类型检查而非方法调用来实现功能控制。比如Cloneable接口,是一个空接口,没有实现任何方法,仅作为类型标识，告知JVM允许对象克隆,不强制实现任何方法，但会改变Object.clone()的行为,通俗点说只有实现了这个接口,当前类的对象才会被允许克隆
关于浅克隆和深克隆,
浅克隆：
仅复制对象本身及基本类型字段，引用类型字段共享原对象地址。修改克隆对象的引用字段会影响原对象，适用于简单对象或不可变对象组合。深克隆：
递归复制对象及其所有引用对象，创建完全独立的副本。克隆对象与原对象完全隔离，适用于复杂对象或需要数据隔离的场景通俗点说就是浅克隆是不管你是基本数据类型还是引用数据类型直接一股脑全拷贝过来,而深克隆是基本数据类型拷贝,字符串复用,引用数据类型就直接创建新的
五、Objects工具类：对象操作增强
作用：空安全的对象操作工具
特点
- 无构造方法（私有化构造，禁止实例化）
- 所有方法均为
static调用
常用方法
| 方法签名 | 图示说明 | 正确实现说明 |
|---|---|---|
public static boolean equals(Object a, Object b) | 空安全对象比较（图示参数错误） | ✅ 实际为两个参数，空指针安全 |
public static boolean isNull(Object obj) | null值判断 | ✅ 等价于obj == null |
public static boolean nonNull(Object obj) | 非null判断 | ✅ 等价于obj != null |
使用示例
空安全对象比较
作用：避免空指针异常的等价性判断
示例：
String str1 = null;
String str2 = "hello";// 传统equals会抛出NullPointerException
// boolean unsafe = str1.equals(str2); // 安全比较方式
boolean safeCompare = Objects.equals(str1, str2);
System.out.println(safeCompare); // 输出: falsenull判断
// 方法实现源码
public static boolean isNull(Object obj) {return obj == null;
}// 使用场景：验证无效参数
public void process(Object param) {if (Objects.isNull(param)) {throw new IllegalArgumentException("参数不能为null");}// ...业务逻辑
}非null判断
// 方法实现源码
public static boolean nonNull(Object obj) {return obj != null;
}// 使用场景：流式过滤
List<String> list = Arrays.asList("a", null, "c");
List<String> validList = list.stream().filter(Objects::nonNull).collect(Collectors.toList());
// 结果: ["a", "c"]特别说明
优先使用Objects.equals
替代传统a.equals(b)，避免空指针异常：
// 传统危险写法
if (user.getName().equals("admin")) {...}// 安全写法
if (Objects.equals(user.getName(), "admin")) {...}参数校验组合技
// 同时验证null和空字符串
if (Objects.isNull(input) || input.isEmpty()) {throw new IllegalArgumentException("非法输入");
}Lambda表达式配合
// 过滤null值集合
List<Object> data = Arrays.asList("a", null, 123);
data.removeIf(Objects::isNull); // 结果: ["a", 123]六、BigInteger：超大整数运算
作用：处理超过long范围的整数
构造方法
| 方法签名 | 作用说明 | 使用场景 |
|---|---|---|
new BigInteger(String val) | 十进制字符串构造 | 处理超过Long范围的大数 |
new BigInteger(String val, int radix) | 指定进制字符串构造 | 二进制/十六进制数据转换 |
BigInteger.valueOf(long val) | long类型转换构造 | 处理常规整数 |
实例化代码示例
字符串构造
// 处理10^30级别大数
BigInteger big1 = new BigInteger("123456789012345678901234567890");// 二进制数据转换（radix=2）
BigInteger binary = new BigInteger("1100001101010000111111010011000", 2);
System.out.println(binary); // 输出十进制值：1048575999992// 十六进制构造（radix=16）
BigInteger hex = new BigInteger("1a3f", 16);
System.out.println(hex); // 输出十进制值：6719数值转换构造
// long类型安全转换
BigInteger num = BigInteger.valueOf(999999999L);// 注意：valueOf不能超过Long范围
// BigInteger error = BigInteger.valueOf(9223372036854775808L); // 越界报错常用方法
| 方法签名 | 说明 | 注意事项 |
|---|---|---|
public BigInteger add(BigInteger val) | 加法运算 | 返回新对象，原值不变 |
public BigInteger subtract(BigInteger val) | 减法运算 | 被减数需大于减数否则结果为负 |
public BigInteger multiply(BigInteger val) | 乘法运算 | 支持任意位数的整数相乘 |
public BigInteger divide(BigInteger val) | 除法获取商 | 除数为零会抛出ArithmeticException |
public BigInteger[] divideAndRemainder(BigInteger val) | 同时获取商和余数 | 返回长度为2的数组（商,余数） |
public boolean equals(Object x) | 比较数值相等性 | 类型不同直接返回false |
public BigInteger pow(int exponent) | 幂运算 | 指数必须为非负数 |
public BigInteger max/min(BigInteger val) | 比较返回较大/较小值 | 空参数会抛NullPointerException |
public int intValue() | 转换为int类型 | 超出int范围会产生数据错误 |
使用示例
基础四则运算
BigInteger a = new BigInteger("1000000000000");
BigInteger b = new BigInteger("999999999999");// 加法
BigInteger sum = a.add(b); // → 1999999999999// 减法
BigInteger diff = a.subtract(b); // → 1// 乘法
BigInteger product = a.multiply(new BigInteger("2")); // → 2000000000000// 除法
BigInteger quotient = a.divide(new BigInteger("3")); // → 333333333333商余运算
BigInteger num = new BigInteger("100");
BigInteger divisor = new BigInteger("7");BigInteger[] result = num.divideAndRemainder(divisor);
System.out.println("商：" + result[0] + " 余数：" + result[1]);
// 输出：商：14 余数：2幂运算
BigInteger base = new BigInteger("5");
BigInteger power = base.pow(20);
// → 95367431640625极值比较
BigInteger x = new BigInteger("123456");
BigInteger y = new BigInteger("654321");BigInteger maxVal = x.max(y); // → 654321
BigInteger minVal = x.min(y); // → 123456类型转换
BigInteger hugeNum = new BigInteger("2147483648"); // 超过int最大值int unsafe = hugeNum.intValue(); // → -2147483648（溢出错误）
int safe = hugeNum.min(BigInteger.valueOf(Integer.MAX_VALUE)).intValue(); // → 2147483647数值比较
BigInteger num1 = new BigInteger("100");
BigInteger num2 = new BigInteger("100");boolean eq1 = num1.equals(num2); // → true
boolean eq2 = num1.equals("100"); // → false（类型不同）特点说明
不可变性原则
所有运算都返回新对象，原对象不变：
BigInteger origin = new BigInteger("10");
origin.add(new BigInteger("5")); // origin仍然为10安全转换策略
数值转换前进行范围检查：
if(bigNum.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) > 0) {throw new ArithmeticException("超出int范围");
} 精确计算替代方案
替代浮点运算实现精确计算：
// 计算(10^15 + 5)/3
BigInteger result = new BigInteger("1000000000000005").divide(new BigInteger("3")); // → 333333333333335七、BigDecimal：高精度浮点运算
作用：解决double精度丢失问题
构造方法
| 方法签名 | 作用说明 | 使用场景 | 注意事项 |
|---|---|---|---|
new BigDecimal(String val) | 字符串构造（推荐方式） | 精确表示小数 | 禁止使用非数字字符 |
new BigDecimal(double val) | 双精度浮点数构造（不推荐） | 快速转换已有double值 | 存在精度丢失风险 |
BigDecimal.valueOf(double val) | 工厂方法构造 | 替代new BigDecimal(double) | 部分数值有缓存优化 |
new BigDecimal(int val) | 整数构造 | 处理整型数据 | 等价于valueOf(int) |
new BigDecimal(long val) | 长整型构造 | 处理大整数 | 超过Long范围需用字符串构造 |
具体使用示例
字符串构造
// 精确表示0.1（推荐）
BigDecimal d1 = new BigDecimal("0.1"); // 科学计数法支持
BigDecimal d2 = new BigDecimal("2.5e3"); // → 2500// 错误示例（包含非数字字符）
BigDecimal error = new BigDecimal("12a.34"); // 抛出NumberFormatException数值构造
// int构造（适用于整数）
BigDecimal intVal = new BigDecimal(100); // long构造（最大支持到Long.MAX_VALUE）
BigDecimal longVal = new BigDecimal(9223372036854775807L);// 超过Long范围必须用字符串
BigDecimal hugeNum = new BigDecimal("9223372036854775808"); // → 比Long.MAX大1double相关构造
// 危险方式（精度丢失）
BigDecimal bad = new BigDecimal(0.1);
System.out.println(bad); // → 0.100000000000000005551115...// 改进方式（仍不推荐）
BigDecimal better = BigDecimal.valueOf(0.1);
System.out.println(better); // → 0.1（内部使用Double.toString转换）// 最佳实践：所有double转换都先用字符串包装
double temp = 0.1;
BigDecimal best = new BigDecimal(Double.toString(temp));常用方法
| 方法签名 | 作用说明 | 参数说明 |
|---|---|---|
public static BigDecimal valueOf(double val) | 双精度浮点数转BigDecimal | 存在精度损失风险，推荐字符串构造 |
public BigDecimal add(BigDecimal val) | 精确加法 | 返回新对象，原值不变 |
public BigDecimal subtract(BigDecimal val) | 精确减法 | 被减数需大于减数可返回负值 |
public BigDecimal multiply(BigDecimal val) | 精确乘法 | 支持任意位数计算 |
public BigDecimal divide(BigDecimal val) | 基础除法（需指定舍入模式） | 可能抛出ArithmeticException |
public BigDecimal divide(BigDecimal val, int scale, RoundingMode mode) | 安全除法 | scale指定小数位数，mode定义舍入规则 |
使用示例
四则运算
BigDecimal a = new BigDecimal("10.5");
BigDecimal b = new BigDecimal("3");// 加法
BigDecimal sum = a.add(b); // → 13.5// 减法（修正图示中的matrix错误）
BigDecimal diff = a.subtract(b); // → 7.5// 乘法
BigDecimal product = a.multiply(new BigDecimal("2.5")); // → 26.25安全除法
// 基础除法（无限小数会报错）
// BigDecimal error = new BigDecimal("10").divide(new BigDecimal("3")); // 抛出ArithmeticException// 正确做法：指定精度和舍入模式
BigDecimal quotient = new BigDecimal("10").divide(new BigDecimal("3"), 4, // 保留4位小数RoundingMode.HALF_UP // 四舍五入
); // → 3.3333特别说明
构造方法选择
优先使用字符串构造：
// 错误示例（精度丢失）
BigDecimal bad = new BigDecimal(0.1); // 实际值≠0.1// 正确示例
BigDecimal good = new BigDecimal("0.1");舍入模式必选
所有除法操作必须指定舍入模式：
// 正确做法（商业计算常用银行家舍入法）
BigDecimal result = a.divide(b, 2, RoundingMode.HALF_EVEN);不可变性原则
所有运算返回新对象：
BigDecimal origin = new BigDecimal("100");
origin.add(new BigDecimal("50")); // origin仍为100
BigDecimal newVal = origin.add(new BigDecimal("50")); // → 150等值比较规范
使用compareTo()代替equals()：
BigDecimal x = new BigDecimal("2.0");
BigDecimal y = new BigDecimal("2.00");x.equals(y); // → false（精度不同）
x.compareTo(y); // → 0（数值相等）