16. 常用API

常用API

API（Application Programming Interface）是一组为开发人员提供的预定义的类、接口、方法和常量的集合，用于构建Java应用程序。

具体信息及方法请查看 API 帮助文档

1. API

1.1 API 的分类

Java的API分为核心API和扩展API两部分。

• 核心API

  核心API包含了Java语言的基本类库，涵盖了诸如字符串操作、输入输出、集合框架、多线程、网络编程等常用功能。

• 扩展API

  扩展API则提供了更高级的功能，如图形界面编程、数据库访问、XML处理等。

Java API的核心部分由JavaSE（Standard Edition）提供，它是标准的Java平台，涵盖了大多数常见的开发需求。

JavaEE（Enterprise Edition）还提供了用于构建企业级应用的API，如Servlets、JSP、EJB等。

JavaME（Micro Edition）则适用于嵌入式设备和移动设备的API。

1.2 重要概念

当使用Java的API时，有一些重要的概念和注意事项需要了解：

1. 包（Package）：Java的API按照功能的不同被组织成不同的包。

   每个包都有一个唯一的名称，以便于开发人员引用其中的类和接口。例如，java.util包提供了与集合框架相关的类和接口。

2. 类（Class）：类是Java中最基本的概念之一，它用于定义对象的属性和方法。

   API中的类提供了特定功能的实现，例如，java.lang.String类用于操作字符串，java.io.File类用于文件操作等。

3. 接口（Interface）：接口定义了一组方法的契约，它指定了实现类必须实现的方法。

   API中的接口提供了一种标准的方式来实现特定功能，例如，java.util.List接口定义了操作列表的方法。

4. 方法（Method）：方法是类或接口中可执行的代码块，用于实现特定的功能。

   API中的方法提供了对类和对象进行操作的方式，例如，java.util.ArrayList类中的add()方法用于向列表中添加元素。

5. 属性（Property）：属性是类或对象的特征或状态值。

   API中的属性提供了对类和对象属性的访问和操作，例如，java.io.File类中的length属性表示文件的大小。

6. 异常（Exception）：异常是在程序中发生错误或异常情况时抛出的对象。

   API中的方法可能会抛出各种类型的异常，开发人员需要处理这些异常来确保程序的正常运行。

7. 文档（Documentation）：API通常配有详细的文档，其中包含了每个类、接口和方法的说明、用法示例和参数说明等。

   通过阅读文档，开发人员可以了解API的功能、使用方法和注意事项。

使用Java的API时，首先需要引入相应的包，然后创建类的实例或调用静态方法。

1.3 API常用包

当继续介绍Java中的API时，我们可以深入了解一些具体的API类和功能：

1. java.lang包：这个包是Java的核心包之一，其中包含了一些最基本和常用的类，如Object、String、Math等。

   Object类是所有类的父类，提供了一些通用的方法，比如equals()、hashCode()等。String类用于字符串操作，提供了丰富的方法来处理字符串，比如拼接、截取、替换等。

2. java.util包：这个包提供了集合框架和一些实用工具类，它是开发中最常用的包之一。

   ArrayList、LinkedList、HashMap、HashSet等类是集合框架的一部分，用于存储、操作和管理数据集合。还有一些实用工具类，如Date、Calendar、UUID等，用于处理日期、时间和生成唯一标识符。

3. java.io包：这个包提供了用于输入输出的类和接口，用于读写文件、处理流等。

   File类用于操作文件和目录，提供了创建、删除、重命名等功能。InputStream和OutputStream类是输入输出流的基类，用于读取和写入数据。还有一些特定功能的类，如BufferedReader、PrintWriter等，用于高效处理文本输入输出。

4. java.net包：这个包提供了用于网络编程的类和接口，用于实现网络通信和数据传输。

   URL类用于处理URL地址，URLConnection类用于建立与URL之间的连接。ServerSocket和Socket类用于实现服务器和客户端之间的通信。

5. java.awt和javax.swing包：这两个包用于图形用户界面（GUI）编程。

   java.awt包提供了实现GUI组件和窗口的类，如Frame、Button、Label等。javax.swing包基于java.awt包，并提供了更加灵活和强大的GUI组件，如JFrame、JButton、JLabel等。

6. java.sql包：这个包提供了与数据库交互的类和接口，用于执行数据库操作。

   Connection、Statement、ResultSet等类用于与数据库建立连接、执行SQL语句和处理查询结果。

1.4 扩展知识

Java中的API一些其他重要的主题和功能：

1. 多线程：Java API提供了用于创建和管理多线程的类和接口。

   例如，java.lang.Thread类用于创建新的线程，java.util.concurrent包提供了更高级的线程和并发功能，如Executor框架、线程池等。多线程是并行处理任务和提高程序性能的重要方式。

2. 异常处理：Java提供了异常处理机制，使开发人员能够更好地处理错误和异常情况。

   API中的方法可能会抛出各种类型的异常，开发人员需要使用try-catch语句来捕获和处理这些异常。java.lang.Exception类是所有异常类的基类，开发人员还可以自定义自己的异常类来满足特定的需求。

3. 注解（Annotation）：注解是一种元数据机制，用于提供额外的信息和指示给编译器和运行时环境。

   Java API中使用了大量的注解来标记和配置代码，如 @Override、@SuppressWarnings、@Deprecated等。注解可以帮助开发人员进行代码分析、生成文档、实现特定功能等。

4. 测试工具：Java API提供了各种测试工具和框架，帮助开发人员编写和执行单元测试、集成测试等。

   JUnit和TestNG是最常用的单元测试框架，提供了一些断言方法和测试运行器，用于验证代码的正确性。此外，还有Mockito、EasyMock等工具用于模拟和测试依赖关系和外部调用。

5. 序列化：Java API支持对象的序列化和反序列化，使得对象可以在网络传输或保存到文件中。

   java.io.Serializable接口是用于标记可序列化对象的接口，对象需要实现该接口后才能被序列化。
   java.io.ObjectInputStream和java.io.ObjectOutputStream类用于实现对象的反序列化和序列化。

6. 时间和日期：Java 8引入了新的时间和日期API，用于更好地处理时间和日期相关的操作。

   java.time包提供了一系列类，如LocalDateTime、Instant、Duration等，用于表示日期、时间间隔和时刻，并提供了各种方法来执行相关的计算和操作。

7. 数据库访问：Java API提供了许多用于访问和操作数据库的类和接口。

   Java Database Connectivity（JDBC）是Java API的一部分，它提供了一种标准的方法来连接和执行SQL语句与数据库交互。开发人员可以使用JDBC来执行查询、插入、更新和删除数据库中的数据，并处理数据库事务。

8. XML和JSON处理：在现代的应用程序中，XML和JSON是常用的数据交换格式。

   Java API提供了处理XML和JSON的类和接口。例如，JAXP（Java API for XML Processing）提供了处理XML文档的API，可以用于解析、创建和操作XML文档。Java API for JSON Processing（JSON-P）提供了处理JSON数据的API，可用于解析、生成和处理JSON数据。

9. 网络通信：Java API提供了一系列类和接口，用于实现网络通信和传输数据。

   例如，java.net包提供了用于网络编程的类，如Socket、ServerSocket等，可以用于建立客户端和服务器之间的通信。java.nio包提供了更高效的非阻塞I/O操作，如使用通道和缓冲区进行数据传输。

10. 图形和图像处理：Java API提供了一些用于创建和处理图形和图像的类和接口，用于实现图形用户界面（GUI）和图像处理功能。

    例如，java.awt包提供了一些基本的GUI组件和绘图功能，如图形画布、绘制图形等。javax.imageio包提供了用于读取和写入图像文件的类和接口。

11. 加密和安全：Java API提供了各种加密和安全相关的类和接口，用于实现数据的加密、数字签名、密钥管理等功能。

    例如，javax.crypto包提供了用于加密和解密数据的类和接口，如Cipher、KeyGenerator等。java.security包提供了处理数字签名、密钥管理和安全算法的类和接口。

12. 并发和并行：Java API提供了许多用于处理并发和并行编程的类和接口，使开发人员能够更好地利用多核处理器和多线程编程。

    例如，java.util.concurrent包提供了执行并发任务的线程池、并发集合、原子变量等。Java 8引入的Stream API提供了一种函数式的方式来操作数据集合，可以方便地进行并行处理。

13. 图形用户界面（GUI）：Java API提供了用于创建图形用户界面的类和接口。

    其中，Swing是一个强大的库，提供了丰富的GUI组件，如按钮、文本框、面板等，以及布局管理器来帮助开发人员创建各种用户界面。另外，JavaFX是Java平台上的新一代GUI框架，提供了更现代化的界面设计和更丰富的功能。

14. 文件和IO操作：Java提供了处理文件和I/O操作的类和接口。

    java.io包提供了用于读写文件和流的类和接口，如File、InputStream、OutputStream等。java.nio包提供了更高级和高效的非阻塞I/O操作。开发人员可以使用这些API操作文件，读取和写入数据，实现日志记录、数据存储和处理等功能。

15. 图像和多媒体处理：Java API提供了一些用于处理图像和多媒体数据的类和接口。

    例如，javax.imageio包提供了用于读取和写入图像文件的类和接口，可以进行图像格式转换、压缩、调整大小等操作。javax.sound包提供了音频处理和播放的功能。

16. 网络和Web开发：Java提供了一系列用于网络编程和Web开发的类和接口。

    例如，java.net包提供了用于创建网络连接、发送和接收数据的类，可以实现Socket编程、HTTP通信等。Java API还提供了Servlet API和JavaServer Pages（JSP）等用于开发Web应用程序的技术。

17. 数据处理和集合：Java提供了丰富的数据处理和集合类库。

    java.util包提供了各种集合类，如List、Set、Map等，以及排序、过滤、查找等功能。Java 8引入的Stream API提供了更便捷和流畅的方式来处理和操作数据集合。

18. 远程调用和Web服务：Java提供了一些用于远程调用和Web服务的API。

    例如，Java Remote Method Invocation（RMI）允许开发人员在Java应用程序之间进行远程调用，实现跨网络通信。Java API还提供了JAX-RS和JAX-WS等用于开发和部署Web服务的API。

2. Math

Math类所在包为java.lang包，因此在使用的时候不需要进行导包。并且Math类被final修饰了，因此该类是不能被继承的。

Math是Java语言提供的一个与数学运算相关的类。它包含了一系列静态方法，用于执行常见的数学运算和操作。

2.1 概述及功能

Math类是Java编程语言提供的一个内置类，位于java.lang包中。Math类中的方法都是静态方法，因此可以直接通过类名调用，无需创建Math类的实例。

需要注意的是，Math类中的大多数方法都返回double类型的结果。如果需要使用整数类型的结果，可以进行类型转换。此外，由于Math类的方法是静态方法，不会改变其参数的值。

在API文档中没有体现可用的构造方法，因此我们就不能直接通过new关键字去创建Math类的对象。同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。

以下是Math类的一些主要功能：

1. 基本数学运算：Math类提供了诸如加法、减法、乘法和除法等基本数学运算。例如，通过add(double a, double b)方法可以对两个数进行相加，通过subtract(double a, double b)方法可以对两个数进行相减，以此类推。

2. 幂运算和开方：Math类提供了求幂和开方的方法。例如，通过pow(double a, double b)方法可以计算a的b次幂，通过sqrt(double a)方法可以计算a的平方根。

3. 三角函数和反三角函数：Math类包含了常见的三角函数和反三角函数，如sin、cos、tan、asin、acos和atan等。它们接受一个弧度值作为参数，并返回计算结果。

4. 取整操作：Math类提供了取整操作的方法。例如，通过ceil(double a)方法可以对a进行上取整操作，通过floor(double a)方法可以对a进行下取整操作，通过round(double a)方法可以对a进行四舍五入操作。

5. 绝对值和符号操作：Math类提供了求绝对值和符号操作的方法。例如，通过abs(double a)方法可以求a的绝对值，通过signum(double a)方法可以获取a的符号（正数返回1.0，负数返回-1.0，零返回0.0）。

6. 随机数生成：Math类提供了生成随机数的方法。例如，通过random()方法可以生成一个介于0.0和1.0之间的随机数。可以使用这个方法来实现随机数的需求。

2.2 常见方法

方法名	返回值类型	描述	示例
abs(x)	double	返回 x 的绝对值	Math.abs(-5) 返回 5.0
ceil(x)	double	返回大于或等于 x 的最小整数	Math.ceil(3.2) 返回 4.0
floor(x)	double	返回小于或等于 x 的最大整数	Math.floor(3.7) 返回 3.0
round(x)	long	返回四舍五入的整数	Math.round(4.5) 返回 5
max(x, y)	double	返回 x 和 y 之间的较大值	Math.max(8, 5) 返回 8.0
min(x, y)	double	返回 x 和 y 之间的较小值	Math.min(3, 7) 返回 3.0
pow(x, y)	double	返回 x 的 y 次方	Math.pow(2, 3) 返回 8.0
sqrt(x)	double	返回 x 的平方根	Math.sqrt(16) 返回 4.0
sin(x)	double	返回 x 的正弦值（弧度表示）	Math.sin(Math.PI / 2) 返回 1.0
cos(x)	double	返回 x 的余弦值（弧度表示）	Math.cos(0) 返回 1.0
tan(x)	double	返回 x 的正切值（弧度表示）	Math.tan(Math.PI / 4) 返回 1.0
asin(x)	double	返回 x 的反正弦值（弧度表示）	Math.asin(1) 返回 1.5707963267948966
acos(x)	double	返回 x 的反余弦值（弧度表示）	Math.acos(0) 返回 1.5707963267948966
atan(x)	double	返回 x 的反正切值（弧度表示）	Math.atan(1) 返回 0.7853981633974483
exp(x)	double	返回 e 的 x 次方	Math.exp(1) 返回 2.718281828459045
log(x)	double	返回 x 的自然对数	Math.log(10) 返回 2.302585092994046
log10(x)	double	返回以 10 为底的 x 的对数	Math.log10(100) 返回 2.0
random()	double	返回一个范围在 0.0 到 1.0 之间的随机浮点数	Math.random() 返回 0.8311543445809906

2.3 注意事项

在使用Math类进行数学运算时的注意事项：

1. 返回类型：Math类中的大多数方法返回的是double类型，即使参数是整数。这意味着可能需要进行类型转换，以便将结果存储在适当的数据类型中。

2. 有限精度：由于使用浮点数进行计算，Math类中的一些方法可能会存在精度丢失的问题。这意味着在比较浮点数时，应使用一些容忍误差的比较方法，而不是简单地进行相等性比较。

3. 可能的溢出：在执行一些数值计算时，特别是使用Exact方法进行整数计算时，需要注意溢出的可能性。Exact方法会检查结果是否会超过整数范围，并在发生溢出时抛出异常。

4. 参数范围：某些方法对参数有限制，例如，log方法要求参数必须为正数，否则会返回NaN。因此，在使用这些方法之前，应确保参数满足方法的要求，以避免出现意外的结果。

5. Math类中的方法都是静态方法，因此你可以直接通过类名调用这些方法，而不需要实例化Math类的对象。

3. System

System类所在包为java.lang包，因此在使用的时候不需要进行导包。并且System类被final修饰了，因此该类是不能被继承的。

System包含了系统操作的一些常用的方法。比如获取当前时间所对应的毫秒值，再比如终止当前JVM等等。

3.1 概述及功能

在API文档中没有体现可用的构造方法，因此我们就不能直接通过new关键字去创建System类的对象。同时我们发现System类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用（Nested Class Summary内部类或者内部接口的描述）。

以下是System类的一些主要功能：

1. 标准输入输出：System类提供了in、out和err三个静态成员变量，它们分别表示标准输入、标准输出和标准错误输出。可以使用它们来实现与用户的交互或输出信息到控制台。

2. 系统属性：通过getProperty(String key)方法，可以获取与系统相关的属性值，例如操作系统的名称、版本和文件分隔符等。可以使用这些属性值来适应不同的操作系统环境。

3. 环境变量：通过getenv(String name)方法，可以获取系统的环境变量值。可以通过环境变量来配置程序的行为或获取系统级别的配置信息。

4. 当前时间：System类提供了currentTimeMillis()方法，可以获取从1970年1月1日午夜以来的当前时间的毫秒数。这对于记录操作时间或性能统计非常有用。

5. 复制数组：System类提供了arraycopy(Object src, int srcPos, Object dest, int destPos, int length)方法，用于在数组之间进行复制。可以使用它来实现数组的拷贝或部分元素的复制。

6. 垃圾回收：通过gc()方法，可以显式地触发Java虚拟机的垃圾回收器，以回收无用的对象。与Runtime类的gc()方法类似。

7. 程序终止：System类提供了exit(int status)方法，用于终止当前正在执行的Java虚拟机。可以指定一个状态码，并将其传递给操作系统。这对于在特定情况下强制终止程序是有用的。

3.2 常见方法

方法	说明	示例
exit(int status)	终止当前正在运行的Java虚拟机	System.exit(0); // 正常退出程序
currentTimeMillis()	返回当前时间戳	long currentTime =System.currentTimeMillis();
gc()	运行垃圾回收器	System.gc(); // 手动触发垃圾回收
arraycopy(Object src, int srcPos, Object dest, int destPos, int length)	将数组中的某一段元素复制到另一个数组中	System.arraycopy(srcArray, 0, destArray, 0, srcArray.length);

// src: 	 源数组
// srcPos：  源数值的开始位置
// dest：    目标数组
// destPos： 目标数组开始位置
// length:   要复制的元素个数
public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length); 

arraycopy方法注意细节：

1.如果数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则会报错

2.在拷贝的时候需要考虑数组的长度，如果超出范围也会报错

3.如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型

3.3 注意事项

在使用System类时的注意事项：

1. System类中的方法大多数都是静态方法，可以直接通过类名来调用，而无需实例化System对象。

2. System类中的方法通常用于执行与系统相关的操作，例如程序的终止、垃圾回收、获取系统属性等。

3. 调用System.exit()方法会立即终止当前正在运行的Java虚拟机，因此要谨慎使用。合理地管理程序流程可以避免不必要的退出。

4. System.currentTimeMillis()方法返回当前时间的毫秒数。注意，这是一个从某个固定时间点开始的累计毫秒数，并非一个可靠的计时器。

5. System.arraycopy()方法用于数组之间的复制，但需要确保源数组和目标数组的类型和长度是兼容的。

6. 当需要与系统打交道、进行输入输出操作时，System类提供了标准输入输出流（System.in和System.out）。

7. System类还提供了一些有关系统属性和环境变量的方法，例如getProperty()和getenv()，可以用于获取系统配置信息。

4. Runtime

Runtime是Java语言提供的一个与运行时环境相关的类。它代表了Java虚拟机的运行时环境，并提供了访问和控制Java虚拟机的相关功能的方法。

Runtime类是一个单例类，也就是说在一个Java虚拟机中只会存在一个Runtime对象。可以通过调用静态方法Runtime.getRuntime()来获取Runtime对象的引用。

4.1 概述及功能

Runtime类提供了一系列与操作系统交互、内存管理、执行外部命令等相关的方法。

以下是Runtime类的一些主要功能：

1. 执行外部命令：通过调用exec(String command)方法，可以在单独的进程中执行指定的命令。这对于需要与操作系统交互的任务非常有用，例如执行系统命令、调用外部程序等。

2. 管理内存：通过totalMemory()、freeMemory()和maxMemory()方法，可以获取Java虚拟机的内存使用情况，并进行内存管理。可以获得Java虚拟机的堆内存总量、空闲内存量以及最大可用内存量。

3. 运行垃圾回收器：通过gc()方法，可以显式地触发Java虚拟机的垃圾回收器，以回收无用的对象。这在需要确保及时释放内存的情况下是有用的。

4. 获取可用处理器数量：通过availableProcessors()方法，可以获取当前系统可用的处理器数量。这对于编写多线程程序或进行并发编程时非常有用。

5. 注册关闭钩子：通过调用addShutdownHook(Thread hook)方法，可以注册一个线程，在Java虚拟机关闭之前执行一些清理或收尾工作。这在确保资源的正确释放和状态的保存时非常有用。

4.2 常见方法

方法	说明	示例
getRuntime()	返回与当前 Java 应用程序关联的 Runtime 对象	Runtime runtime = Runtime.getRuntime();
exec(String command)	在单独的进程中执行指定的命令	runtime.exec("ls -l");
totalMemory()`	返回 Java 虚拟机中的堆总内存量	`long totalMem = runtime.totalMemory();
`freeMemory()	返回 Java 虚拟机中的空闲堆内存量	`long freeMem = runtime.freeMemory();
`gc()	运行垃圾回收器	`runtime.gc();
`availableProcessors()	返回虚拟机可用的处理器数量	int processors = runtime.availableProcessors();`
addShutdownHook(Thread hook)`	注册一个新的虚拟机关闭挂钩，以便在关闭之前执行清理或其他操作	`runtime.addShutdownHook(new Thread(() -> { // … cleanup code }));
`halt(int status)	强制退出 Java 虚拟机。与 System.exit() 不同，它完全终止虚拟机而不执行清理操作	`runtime.halt(0);

代码示例：

public class RunTimeDemo1 {
    public static void main(String[] args) throws IOException {
        /*
            public static Runtime getRuntime() 当前系统的运行环境对象
            public void exit(int status) 停止虚拟机
            public int availableProcessors() 获得CPU的线程数
            public long maxMemory() JVM能从系统中获取总内存大小(单位byte)
            public long totalMemory() JVM已经从系统中获取总内存大小(单位byte)
            public long freeMemory() JVM剩余内存大小(单位byte)
            public Process exec(string command) 运行cmd命令
        */

        //1.获取Runtime的对象
        //Runtime r1 =Runtime.getRuntime();

        //2.exit 停止虚拟机
        //Runtime.getRuntime().exit(0);
        //System.out.println("看看我执行了吗?");


        //3.获得CPU的线程数
        System.out.println(Runtime.getRuntime().availableProcessors());//8
        //4.总内存大小,单位byte字节
        System.out.println(Runtime.getRuntime().maxMemory() / 1024 / 1024);//4064
        //5.已经获取的总内存大小,单位byte字节
        System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);//254
        //6.剩余内存大小
        System.out.println(Runtime.getRuntime().freeMemory() / 1024 / 1024);//251

        //7.运行cmd命令
        //shutdown :关机
        //加上参数才能执行
        //-s :默认在1分钟之后关机
        //-s -t 指定时间 : 指定关机时间
        //-a :取消关机操作
        //-r: 关机并重启
        Runtime.getRuntime().exec("shutdown -s -t 3600");
    }
}

4.3 注意事项

在使用Runtime类时的注意事项：

1. 进程管理：Runtime类允许您执行外部命令并管理系统进程。然而，执行外部命令可能涉及到与操作系统交互，因此需要谨慎处理。确保您的代码只执行受信任的命令，避免执行恶意或未知来源的命令。

2. 系统资源：执行外部命令可能消耗系统资源，如CPU、内存和文件句柄等。如果您在代码中频繁地执行外部命令，可能会对系统性能产生负面影响。因此，需要慎重选择执行外部命令的时机和频率，以避免不必要的资源消耗。

3. 安全性：由于Runtime类允许执行外部命令，因此在使用时需要格外注意代码的安全性。确保您的代码没有潜在的安全漏洞，以防止恶意命令的执行或系统被攻击。避免接受来自用户或不可信源的输入，以及不要将机密信息传递给外部命令。

4. 异常处理：在执行外部命令时，可能会出现各种异常情况，如命令执行失败、命令不存在等。为了保证代码的健壮性，需要适当地捕获和处理可能的异常，并提供适当的错误处理和错误消息。

5. 跨平台兼容性：Runtime类的一些方法在不同的操作系统上可能会有不同的行为或支持程度。因此，在编写代码时需要注意跨平台兼容性，并对不同的操作系统环境进行适当的处理和测试，以确保代码在各种环境下都能正常运行。

5. Object

Object类的详细描写

6. Objects

Objects类的详细描写

7. BigInteger

BigInteger 是 Java 中的一个类，它提供了对任意长度整数的支持。它位于 java.math 包中，用于处理大整数运算，超过了原始数据类型（如 int 或 long）的取值范围限制。

7.1 概述及功能

BigInteger 类的主要功能如下：

1. 大整数运算：BigInteger 支持对大整数进行基本的数学运算，包括加法、减法、乘法、除法、模运算等。这些运算可以在任意长度的整数上进行，不受位数限制。

2. 大整数比较：BigInteger 提供了用于比较大小的方法，如 compareTo()、equals()、compareTo() 等。这些方法使我们可以精确比较大整数的大小关系。

3. 大整数转换：BigInteger 支持与其他数据类型之间的转换，如将 BigInteger 转换为 int、long、float、double 等，反之亦然。这允许在大整数和其他数据类型之间进行相互转换。

4. 大整数格式化：BigInteger 支持以不同的进制（如十进制、十六进制等）格式化大整数的输出。它提供了 toString() 方法，使我们可以方便地将大整数转换为字符串。

5. 大整数幂运算：BigInteger 提供了 pow() 方法，用于计算大整数的幂。这使得我们可以进行大整数的指数运算，获得指定幂次的结果。

6. 大整数的位操作：BigInteger 支持对大整数进行位操作，如位与、位或、位异或等。这些操作可以在二进制表示下对大整数的每一位进行计算。

7.2 常用方法

以下是 BigInteger 类的常见方法及其示例：

方法	描述	示例
`add(BigInteger val)	将当前大整数与参数值相加，并返回结果。	`BigInteger result = bigInteger1.add(bigInteger2)
`subtract(BigInteger val)	从当前大整数中减去参数值，并返回结果。	`BigInteger result = bigInteger1.subtract(bigInteger2);
`multiply(BigInteger val)	将当前大整数与参数值相乘，并返回结果。	`BigInteger result = bigInteger1.multiply(bigInteger2);
`divide(BigInteger val)	将当前大整数除以参数值，并返回结果。	`BigInteger result = bigInteger1.divide(bigInteger2);
`mod(BigInteger val)	计算当前大整数除以参数值的模，并返回结果。	`BigInteger result = bigInteger1.mod(bigInteger2);
`pow(int exponent)	将当前大整数的指定幂次幂运算，并返回结果。	`BigInteger result = bigInteger1.pow(2);
`abs()	返回当前大整数的绝对值。	`BigInteger result = bigInteger.abs();
`negate()	返回当前大整数的相反数。	`BigInteger result = bigInteger.negate();
`compareTo(BigInteger val)	将当前大整数与参数值进行比较，返回负整数、零或正整数。	`int result = bigInteger1.compareTo(bigInteger2);
`equals(Object obj)	检查当前大整数是否与给定对象相等。	`boolean result = bigInteger1.equals(bigInteger2);
`toString()	返回当前大整数的字符串表示。	`String result = bigInteger.toString();
`intValue()	返回当前大整数的整型值。	`int result = bigInteger.intValue();
`longValue()	返回当前大整数的长整型值。	`long result = bigInteger.longValue();
`floatValue()	返回当前大整数的浮点型值。	`float result = bigInteger.floatValue();
`doubleValue()	返回当前大整数的双精度浮点型值。	`double result = bigInteger.doubleValue();
`bitCount()	返回当前大整数的二进制表示中的位数。	`int result = bigInteger.bitCount();
`shiftLeft(int n)	将当前大整数向左移动指定的位数。	`BigInteger result = bigInteger.shiftLeft(2);
`shiftRight(int n)	将当前大整数向右移动指定的位数。	`BigInteger result = bigInteger.shiftRight(2);

例如：

import java.math.BigInteger;

public class BigIntegerExample {
    public static void main(String[] args) {
        BigInteger bigInteger1 = new BigInteger("1234567890");
        BigInteger bigInteger2 = new BigInteger("9876543210");

        // add(BigInteger val)
        BigInteger resultAdd = bigInteger1.add(bigInteger2);
        System.out.println("Addition result: " + resultAdd);

        // subtract(BigInteger val)
        BigInteger resultSubtract = bigInteger1.subtract(bigInteger2);
        System.out.println("Subtraction result: " + resultSubtract);

        // multiply(BigInteger val)
        BigInteger resultMultiply = bigInteger1.multiply(bigInteger2);
        System.out.println("Multiplication result: " + resultMultiply);

        // divide(BigInteger val)
        BigInteger resultDivide = bigInteger1.divide(bigInteger2);
        System.out.println("Division result: " + resultDivide);

        // mod(BigInteger val)
        BigInteger resultMod = bigInteger1.mod(bigInteger2);
        System.out.println("Modulus result: " + resultMod);

        // pow(int exponent)
        BigInteger resultPow = bigInteger1.pow(2);
        System.out.println("Power result: " + resultPow);

        // abs()
        BigInteger resultAbs = bigInteger1.abs();
        System.out.println("Absolute value: " + resultAbs);

        // negate()
        BigInteger resultNegate = bigInteger1.negate();
        System.out.println("Negate value: " + resultNegate);

        // compareTo(BigInteger val)
        int resultCompare = bigInteger1.compareTo(bigInteger2);
        System.out.println("Comparison result: " + resultCompare);

        // equals(Object obj)
        boolean resultEquals = bigInteger1.equals(bigInteger2);
        System.out.println("Equality result: " + resultEquals);

        // toString()
        String resultString = bigInteger1.toString();
        System.out.println("String representation: " + resultString);

        // intValue()
        int resultInt = bigInteger1.intValue();
        System.out.println("Integer value: " + resultInt);

        // longValue()
        long resultLong = bigInteger1.longValue();
        System.out.println("Long value: " + resultLong);

        // floatValue()
        float resultFloat = bigInteger1.floatValue();
        System.out.println("Float value: " + resultFloat);

        // doubleValue()
        double resultDouble = bigInteger1.doubleValue();
        System.out.println("Double value: " + resultDouble);

        // bitCount()
        int resultBitCount = bigInteger1.bitCount();
        System.out.println("Bit count: " + resultBitCount);

        // shiftLeft(int n)
        BigInteger resultShiftLeft = bigInteger1.shiftLeft(2);
        System.out.println("Shift left result: " + resultShiftLeft);

        // shiftRight(int n)
        BigInteger resultShiftRight = bigInteger1.shiftRight(2);
        System.out.println("Shift right result: " + resultShiftRight);
    }
}

7.3 注意事项

当使用 BigInteger 类时，有几个注意事项需要考虑：

1. 构造函数：你可以使用不同的方式来初始化 BigInteger 对象。你可以传入一个整数、一个字符串表示的整数或另一个 BigInteger 对象。确保使用适当的构造函数来初始化对象。

2. 不可变性：BigInteger 是不可变的，这意味着一旦创建了一个 BigInteger 对象，就无法更改它的值。如果你需要更改 BigInteger 变量的值，你将要创建一个新的对象。

3. 运算符方法：BigInteger 类为常见的数学运算符（如加法、减法、乘法和除法）提供了方法。要执行这些操作，请使用相应的方法，而不是直接使用运算符。例如，使用 add() 方法来执行加法运算，而不是使用 + 运算符。

4. 精度和范围：BigInteger 可以处理任意大小的整数，但以大整数的计算代价会很高。要注意计算的速度和内存消耗，确保你的计算不会超出处理范围。

5. 比较方法：BigInteger 提供了几种比较方法，如 compareTo()、equals() 和 compareTo()。根据你的需求选择合适的比较方法。

6. 异常处理：在处理特定方法时，如 divide() 和 mod()，要注意处理可能抛出的异常，如 ArithmeticException。这些方法在某些情况下可能会引发异常，如除以零或对负数取模。

7. 类型转换：如果需要，可以将 BigInteger 转换为其他数据类型，如 int 或 long。但要注意，这可能导致丢失精度或溢出。

8. BigDecimal

BigDecimal 是 Java 中用于精确计算大数的类。与 double 和 float 类型不同，BigDecimal 提供了任意精度的十进制数，可以准确地表示和计算大数，避免了精度损失的问题。

8.1 概述及功能

以下是 BigDecimal 类的一些功能：

1. 任意精度计算：BigDecimal 可以处理任意精度的数值计算，不受位数限制。它可以表示非常大的数或非常小的数，以及强制精确的小数位数。

2. 保留精度：BigDecimal 类可以指定要保留的小数位数，以及舍入模式。你可以选择四舍五入、向上取整、向下取整等舍入模式，以满足你的精确计算需求。

3. 数值运算：BigDecimal 支持常见的数值运算，如加法、减法、乘法和除法。它提供了对这些运算的方法，如 add()、subtract()、multiply() 和 divide()。

4. 比较和相等判断：BigDecimal 提供了比较和相等判断的方法，如 compareTo()、equals() 和 compareTo()。你可以使用这些方法来比较两个 BigDecimal 对象的大小，或者判断它们是否相等。

5. 数值转换：BigDecimal 可以与其他数值类型进行转换，如 int、long、float 和 double。可以使用 intValue()、longValue()、floatValue() 和 doubleValue() 方法将 BigDecimal 转换为相应的数值类型。

6. 大数运算：BigDecimal 可以处理无限位数的数值计算，因此可以进行大数运算。这对于处理金融、科学或其他需要高精度计算的领域非常有用。

8.2 常用方法

下表列出了 BigDecimal 类中一些常用的方法及其简单说明和示例：

方法	说明	示例
add()`	加法运算	BigDecimal result = num1.add(num2);`
subtract()`	减法运算	BigDecimal result = num1.subtract(num2);`
multiply()`	乘法运算	BigDecimal result = num1.multiply(num2);`
divide()`	除法运算	BigDecimal result = num1.divide(num2, RoundingMode.HALF_UP);`
remainder()`	求余数	BigDecimal result = num1.remainder(num2);`
pow()`	指数运算	BigDecimal result = num1.pow(2);`
abs()`	绝对值	BigDecimal result = num.abs();`
round()`	四舍五入	BigDecimal result = num.round(new MathContext(2, RoundingMode.HALF_UP));`
setScale()`	设置小数位数	BigDecimal result = num.setScale(2, RoundingMode.HALF_UP);`
compareTo()`	比较大小	int result = num1.compareTo(num2);`
equals()`	判断是否相等	boolean result = num1.equals(num2);`
intValue()`	转换为整型	int result = num.intValue();`
longValue()`	转换为长整型	long result = num.longValue();`
floatValue()`	转换为单精度浮点数	float result = num.floatValue();`
doubleValue()`	转换为双精度浮点数	double result = num.doubleValue();`
toString()`	转换为字符串	String result = num.toString();`

举例：

• add() - 加法运算

这个方法用于执行两个 BigDecimal 对象的加法运算，并返回结果。下面是一个示例：

BigDecimal num1 = new BigDecimal("10.5");
BigDecimal num2 = new BigDecimal("5.3");
BigDecimal result = num1.add(num2); // 10.5 + 5.3 = 15.8

• subtract() - 减法运算

这个方法用于执行两个 BigDecimal 对象的减法运算，并返回结果。下面是一个示例：

BigDecimal num1 = new BigDecimal("10.5");
BigDecimal num2 = new BigDecimal("5.3");
BigDecimal result = num1.subtract(num2); // 10.5 - 5.3 = 5.2

• multiply() - 乘法运算

这个方法用于执行两个 BigDecimal 对象的乘法运算，并返回结果。下面是一个示例：

BigDecimal num1 = new BigDecimal("10.5");
BigDecimal num2 = new BigDecimal("5.3");
BigDecimal result = num1.multiply(num2); // 10.5 * 5.3 = 55.65

• divide() - 除法运算

这个方法用于执行两个 BigDecimal 对象的除法运算，并返回结果。第二个参数用于指定舍入模式。下面是一个示例：

BigDecimal num1 = new BigDecimal("10.5");
BigDecimal num2 = new BigDecimal("5.3");
BigDecimal result = num1.divide(num2, RoundingMode.HALF_UP); // 10.5 / 5.3 = 1.981...

• remainder() - 求余数

这个方法用于计算两个 BigDecimal 对象的余数，并返回结果。下面是一个示例：

BigDecimal num1 = new BigDecimal("10.5");
BigDecimal num2 = new BigDecimal("5.3");
BigDecimal result = num1.remainder(num2); // 10.5 % 5.3 = 0.2

• pow() - 指数运算

这个方法用于计算 BigDecimal 对象的指数，并返回结果。下面是一个示例：

BigDecimal num = new BigDecimal("2.5");
BigDecimal result = num.pow(2); // 2.5的2次方 = 6.25

• abs() - 绝对值

这个方法用于计算 BigDecimal 对象的绝对值，并返回结果。下面是一个示例：

BigDecimal num = new BigDecimal("-10.5");
BigDecimal result = num.abs(); // |-10.5| = 10.5

• round() - 四舍五入

这个方法用于对 BigDecimal 对象进行四舍五入，并返回结果。下面是一个示例：

BigDecimal num = new BigDecimal("10.566");
BigDecimal result = num.round(new MathContext(2, RoundingMode.HALF_UP)); // 四舍五入保留2位小数 = 10.57

• setScale() - 设置小数位数

这个方法用于设置 BigDecimal 对象的小数位数，并返回结果。第一个参数指定位数，第二个参数指定舍入模式。下面是一个示例：

BigDecimal num = new BigDecimal("10.566");
BigDecimal result = num.setScale(2, RoundingMode.HALF_UP); // 设置小数位数为2，结果为10.57

• compareTo() - 比较大小

这个方法用于比较两个 BigDecimal 对象的大小，返回一个 int 值。下面是一个示例：

BigDecimal num1 = new BigDecimal("10.5");
BigDecimal num2 = new BigDecimal("5.3");
int result = num1.compareTo(num2); // 返回 1，因为10.5 > 5.3

• equals() - 判断是否相等

这个方法用于判断两个 BigDecimal 对象是否相等，返回一个 boolean 值。下面是一个示例：

BigDecimal num1 = new BigDecimal("10.5");
BigDecimal num2 = new BigDecimal("10.50");
boolean result = num1.equals(num2); // 返回 false，因为两个对象的值相等但精度不同

• intValue() - 转换为整型

这个方法用于将 BigDecimal 对象转换为整型，并返回结果。下面是一个示例：

BigDecimal num = new BigDecimal("10.5");
int result = num.intValue(); // 结果为 10

• doubleValue() - 转换为双精度数

这个方法用于将 BigDecimal 对象转换为双精度数，并返回结果。下面是一个示例：

BigDecimal num = new BigDecimal("10.5");
double result = num.doubleValue(); // 结果为 10.5

• toString() - 转换为字符串

这个方法用于将 BigDecimal 对象转换为字符串，并返回结果。下面是一个示例：

BigDecimal num = new BigDecimal("10.5");
String result = num.toString(); // 结果为 "10.5"

8.3 注意事项

BigDecimal类的注意事项：

1. 避免使用BigDecimal的构造函数传递float或double类型的参数，因为这可能会导致精度丢失。最好使用BigDecimal的字符串构造函数，例如new BigDecimal("0.1")。

2. 使用BigDecimal的setScale方法来控制小数的精度和舍入方式。例如，setScale(2, RoundingMode.HALF_UP)将数字舍入到两位小数，并使用常规的四舍五入策略。

3. 不要直接使用BigDecimal的equals方法进行精确的相等性比较，因为它会考虑到数字的精度。应该使用compareTo方法进行比较，或者使用compareTo(BigDecimal.ZERO) == 0来检查是否为零。

4. 当进行算术运算时，要注意处理BigDecimal的精度。例如，使用add方法进行加法运算时，结果的精度可能超过原始操作数的精度，需要使用setScale方法进行适当的舍入。

5. 避免使用BigDecimal作为HashMap或HashSet的键，因为BigDecimal的hashCode方法计算会消耗较多的计算资源，而且可能会导致性能下降。

6. 当比较BigDecimal对象时，使用compareTo方法而不是==或!=操作符，因为BigDecimal是一个引用类型，而不是基本类型。

7. 注意避免在循环中创建大量的BigDecimal对象，这可能会导致性能问题。最好在循环外部创建BigDecimal对象，并在循环内部重复使用它们。

详细方法请查看 API 帮助文档