Java 复习笔记 - 常用API 上

---

一，API 概述

Java API是Java语言提供的一组类和接口的集合，用于开发Java应用程序。它包含了各种功能模块，如图形界面、网络通信、数据库访问、多线程、文件操作等，以及一些常用的数据结构和算法。

Java API的设计目标是提供一组可靠、高效、易用的工具和功能，以帮助开发人员更快速地构建应用程序。它提供了丰富的类和接口，开发人员可以根据自己的需求来选择和使用这些API。

Java API按功能划分为多个包，如java.lang、java.util、java.io等。每个包都包含了一组相关的类和接口，方便开发人员进行模块化开发和代码重用。

使用Java API可以大大简化开发过程，开发人员不需要从头开始设计和实现各种功能，而是直接使用API提供的类和方法即可。同时，Java API还提供了文档和示例代码，方便开发人员学习和使用。

总之，Java API是Java语言的核心部分，提供了丰富的工具和功能，帮助开发人员更高效地开发Java应用程序。

二，Math

（一）Math 概述

Java中的Math类是一个包含数学运算方法的工具类。它提供了许多用于执行常见数学运算的静态方法。以下是一些常见的Math类方法：

1. abs()：返回一个数的绝对值。
2. ceil()：向上取整。
3. floor()：向下取整。
4. round()：四舍五入取整。
5. max()：返回两个数中较大的那个数。
6. min()：返回两个数中较小的那个数。
7. pow()：返回一个数的指定次幂。
8. sqrt()：返回一个数的平方根。
9. random()：返回一个0到1之间的随机数。
10. sin()、cos()、tan()：三角函数。
11. log()、log10()：对数函数。

要使用Math类的方法，只需在方法名前加上类名"Math."即可，例如：

int absoluteValue = Math.abs(-5);
double roundedValue = Math.round(2.6);
double randomValue = Math.random();

可以在Java官方文档中找到更多关于Math类的详细信息和其他方法的使用方式。

（二）Math 练习

1，质数判断

需求：判断一个数是否为质数，使用平方根优化算法。

要判断一个数是否为质数，可以使用平方根优化算法。平方根优化算法的基本思想是，对于一个数n，如果存在一个因子p，使得p * q = n，那么p和q中必然有一个小于等于n的平方根。因此，只需要判断在2到平方根n之间是否存在n的因子即可。

下面是一个使用平方根优化算法判断一个数是否为质数的示例代码：

public class PrimeNumberChecker {
    public static boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }
        
        // 判断在2到平方根number之间是否存在number的因子
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false;
            }
        }
        
        return true;
    }
    
    public static void main(String[] args) {
        int number = 17;
        if (isPrime(number)) {
            System.out.println(number + " is a prime number.");
        } else {
            System.out.println(number + " is not a prime number.");
        }
    }
}

在上面的代码中，isPrime()方法接收一个整数作为参数，判断该数是否为质数。如果数小于等于1，则直接返回false。然后使用平方根优化算法，在2到平方根number之间判断是否存在number的因子，如果存在则返回false；否则返回true。

在main()方法中，我们传入一个数17进行测试。运行代码后，会输出"17 is a prime number."，表示17是一个质数。

你可以根据需要调用isPrime()方法来判断不同的数是否为质数。

2，水仙花数

说明：自幂数，一个n位的自然数等于自身各个数位上数字的n次幂之和。
例1（三位数又称水仙花数）：1^3 + 5^3 + 3^3 = 153
例2（四位数又称四叶玫瑰数）：1^4 + 6^4 + 3^4 + 4^3 = 1634
需求：统计一共有多少个水仙花数。

水仙花数是指一个 n 位正整数，它的各位数字的 n 次幂之和等于它本身。例如，153 是一个水仙花数，因为 1^3 + 5^3 + 3^3 = 153。

下面是一个 Java 程序，用于计算并输出 100 到 999 之间的所有水仙花数：

public class NarcissisticNumbers {
    public static void main(String[] args) {
        for (int i = 100; i <= 999; i++) {
            if (isNarcissistic(i)) {
                System.out.println(i);
            }
        }
    }

    public static boolean isNarcissistic(int num) {
        int original = num;
        int sum = 0;
        int n = String.valueOf(num).length();

        while (num > 0) {
            int digit = num % 10;
            sum += Math.pow(digit, n);
            num /= 10;
        }

        return sum == original;
    }
}

这个程序包含两个方法：main 和 isNarcissistic。main 方法用于遍历 100 到 999 之间的所有整数，并调用 isNarcissistic 方法来检查每个整数是否是水仙花数。如果是，就将其输出到控制台。

isNarcissistic 方法接受一个整数作为参数，并返回一个布尔值，表示该整数是否是水仙花数。该方法首先计算该整数的位数，然后使用循环将其各位数字的 n 次幂加起来，得到一个总和。最后，将总和与原始整数进行比较，如果相等，则返回 true，否则返回 false。

三，System

（一）System 概述

在Java编程语言中，System是一个类，它代表了系统的标准输入、输出和错误输出流。System类还包含一些有关系统运行状态的信息，如当前系统的默认字符集的名称。

System类是Java的核心类库的一部分，它包含以下主要成员：

1. 标准输入流（System.in）：这是程序从用户那里获取输入的主要方式。在Java中，可以使用Scanner类从System.in读取输入。
2. 标准输出流（System.out）：这是程序向用户显示输出的主要方式。在Java中，可以使用System.out.println()或System.out.print()方法向System.out写入输出。
3. 标准错误流（System.err）：这是程序向用户显示错误输出的主要方式。在Java中，可以使用System.err.println()或System.err.print()方法向System.err写入错误输出。
4. 系统属性（System.getProperty()和System.setProperty()）：这些方法用于获取和设置Java系统的属性。例如，可以通过System.getProperty(“os.name”)来获取操作系统的名称。

以下是如何使用System类的例子：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数:");
        int number = scanner.nextInt();
        System.out.println("你输入的整数是: " + number);
    }
}

在这个例子中，我们使用System.in作为Scanner的输入源，然后使用System.out.println()将用户输入的整数打印出来。

（二）System 常用的方法

System类有许多常用的方法，这些方法提供了对系统级功能和操作的访问。以下是一些常用的System类方法：

1. currentTimeMillis()

currentTimeMillis() 是 Java 的 System 类的静态方法，用于返回当前时间以毫秒为单位。它返回的是自1970年1月1日0时0分0秒（UTC）以来的当前时间，以毫秒为单位。这个方法提供了一种简单而高效的方式来获取当前时间。

以下是 currentTimeMillis() 方法的示例用法：

long currentTime = System.currentTimeMillis();
System.out.println("当前时间（毫秒）: " + currentTime);

输出结果将类似于：

当前时间（毫秒）: 1626838345529

此方法非常适用于记录应用程序的运行时间或执行某些操作的时间间隔。

2. arraycopy(src, srcPos, dest, destPos, length)

arraycopy 是 Java 的 System 类的一个静态方法，用于将一个数组的一部分内容复制到另一个数组的相同位置。这个方法非常高效，因为它在底层使用内存直接拷贝，而不是通过循环逐个元素复制。

以下是 arraycopy 方法的签名：

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

参数说明：

• src: 源数组
• srcPos: 源数组的开始位置（从 0 开始）
• dest: 目标数组
• destPos: 目标数组的开始位置（从 0 开始）
• length: 要复制的元素数量

这个方法会将 src 数组从 srcPos 开始，长度为 length 的元素复制到 dest 数组从 destPos 的位置开始。

以下是一个示例：

int[] source = {1, 2, 3, 4, 5};
int[] target = new int[5];

System.arraycopy(source, 0, target, 0, 3);

// 此时 target 为 {1, 2, 3, 0, 0}

在上述示例中，我们使用 arraycopy 方法将 source 数组的前三个元素复制到 target 数组中。注意，target 数组的其余部分被填充为默认值（在这种情况下为 0）。

3. identityHashCode(Object x)

identityHashCode(Object x) 是 Java 的 System 类的静态方法，用于返回对象的身份哈希码。身份哈希码是由系统自动为每个对象存储的唯一标识符，通常用于对象的快速比较或者在哈希表中存储对象。

以下是 identityHashCode() 方法的示例用法：

Object obj = new Object();
int hash = System.identityHashCode(obj);
System.out.println("对象的身份哈希码: " + hash);

输出结果将类似于：

对象的身份哈希码: 182317697

注意：身份哈希码是由 JVM 自动为每个对象生成的，因此不应该被应用程序直接使用。它主要用于底层系统级操作，例如在哈希表中存储对象。

4. in

in 是 Java 的 System 类的静态成员变量，表示标准输入流。它通常用于读取用户输入，可以从键盘输入数据。

以下是使用 in 读取用户输入的示例代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数：");
        int num = scanner.nextInt();
        System.out.println("您输入的整数是：" + num);
    }
}

在上述代码中，我们使用 System.in 作为 Scanner 的输入源，然后通过 Scanner 的 nextInt() 方法读取用户输入的整数。

注意：in 是只读的，不应该被修改。此外，如果需要从其他输入源读取数据，可以使用 InputStream 类型的对象作为 Scanner 的输入源。

5. out

out 是 Java 的 System 类的静态成员变量，表示标准输出流。它通常用于向用户显示输出，可以将数据输出到控制台或者文件中。

以下是使用 out 显示输出的示例代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

在上述代码中，我们使用 System.out.println() 方法向用户输出字符串 “Hello, World!”。

注意：out 是只读的，不应该被修改。此外，如果需要将输出重定向到其他目标，可以使用 PrintStream 类型的对象作为输出流。

6. err

err 是 Java 的 System 类的静态成员变量，表示标准错误流。它通常用于显示程序错误消息，可以将数据输出到控制台或者文件中。

以下是使用 err 显示错误消息的示例代码：

public class Main {
    public static void main(String[] args) {
        int result = 1 / 0; // 除以 0 的错误
        System.err.println("Error: Division by zero!");
    }
}

在上述代码中，我们故意进行除以 0 的错误计算，然后使用 System.err.println() 方法向用户输出自定义的错误消息。

注意：err 是只读的，不应该被修改。此外，如果需要将错误消息重定向到其他目标，可以使用 PrintStream 类型的对象作为错误流。

7. getProperty(String key)

getProperty(String key) 是 Java 的 System 类的静态方法，用于返回与指定键关联的系统属性值。系统属性是 Java 系统运行时环境的一部分，可以提供有关 Java 虚拟机、操作系统、用户环境等信息。

以下是使用 getProperty() 方法获取系统属性的示例代码：

public class Main {
    public static void main(String[] args) {
        String javaVersion = System.getProperty("java.version");
        String osName = System.getProperty("os.name");
        String userHome = System.getProperty("user.home");

        System.out.println("Java Version: " + javaVersion);
        System.out.println("Operating System Name: " + osName);
        System.out.println("User Home Directory: " + userHome);
    }
}

在上述代码中，我们使用 getProperty() 方法分别获取了 Java 版本号、操作系统名称和用户主目录的系统属性值，并输出到控制台。

注意：getProperty() 方法返回的是一个字符串类型的结果，因此在使用时需要注意字符串的解析和处理。此外，如果指定的键不存在于系统属性中，该方法将返回 null 或者一个默认值，具体取决于所使用的 Java 版本和操作系统。

8. setProperty(String key, String value)

setProperty(String key, String value) 是 Java 的 System 类的静态方法，用于将系统属性设置为指定的键和值。通过设置系统属性，可以修改 Java 系统运行时环境的行为和配置。

以下是使用 setProperty() 方法设置系统属性的示例代码：

public class Main {
    public static void main(String[] args) {
        System.setProperty("java.awt.headless", "true"); // 设置系统属性

        // 其他代码
    }
}

在上述代码中，我们使用 setProperty() 方法将名为 “java.awt.headless” 的系统属性设置为 “true”。这个属性用于指定 Java 应用程序是否在无头环境下运行，即没有图形用户界面。通过设置该属性为 “true”，可以禁用图形用户界面相关的功能。

注意：setProperty() 方法设置的系统属性对当前进程及其子进程都有效。但是，当进程结束时，系统属性可能会丢失或重置为默认值。如果需要持久化系统属性，可以考虑将它们写入配置文件或使用数据库等持久化机制进行存储。

9. clearProperty(String key)

clearProperty(String key) 是 Java 的 System 类的静态方法，用于清除指定键的系统属性。通过清除系统属性，可以删除其对应的值，从而恢复到默认状态或者移除特定的配置。

以下是使用 clearProperty() 方法清除系统属性的示例代码：

public class Main {
    public static void main(String[] args) {
        System.clearProperty("java.awt.headless"); // 清除系统属性

        // 其他代码
    }
}

在上述代码中，我们使用 clearProperty() 方法将名为 “java.awt.headless” 的系统属性清除。这将删除该属性的值，使其恢复为默认状态或移除特定的配置。

注意：clearProperty() 方法清除的是当前进程的系统属性。如果其他进程或子进程使用了该属性，它们仍然会保留其值。此外，清除系统属性后，如果再次调用 getProperty() 方法获取该属性的值，可能会返回 null 或者一个默认值，具体取决于所使用的 Java 版本和操作系统。

10. lineSeparator()

lineSeparator() 是 Java 的 System 类的静态方法，用于返回系统行分隔符。系统行分隔符是用于表示文本换行的特定字符序列，它可以是单个字符，如换行符 (‘\n’)，也可以是表示换行的多个字符序列，如 Windows 系统的回车换行符序列 (‘\r\n’)。

以下是使用 lineSeparator() 方法获取系统行分隔符的示例代码：

public class Main {
    public static void main(String[] args) {
        String lineSeparator = System.lineSeparator();
        System.out.println("系统行分隔符是：" + lineSeparator);
    }
}

在上述代码中，我们使用 lineSeparator() 方法获取系统行分隔符，并将其输出到控制台。根据所使用的操作系统和 Java 版本，输出结果可能会有所不同。

注意：使用系统行分隔符可以确保在不同操作系统上的正确换行方式。在输出文本时，将其插入到需要换行的地方，可以确保在各种环境下都能正确显示换行效果。

11. exit(int status)

exit() 是 Java 的 System 类的一个静态方法，用于终止当前正在运行的 Java 虚拟机。这个方法接受一个整数类型的参数，通常用来表示程序的退出状态。

以下是使用 exit() 方法终止 Java 虚拟机的示例代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("程序正在运行...");

        // 调用 exit() 方法终止虚拟机
        System.exit(0);
    }
}

在上述代码中，当程序执行到 System.exit(0) 时，Java 虚拟机将终止运行。其中，参数 0 表示程序正常退出。如果需要表示异常退出，可以使用非零值作为参数。

注意：exit() 方法只能在应用程序的主线程中调用。此外，在调用 exit() 方法之前，应该确保所有已创建的线程和对象都已经正确地被释放和关闭，以避免资源泄漏和其他问题。

这些方法使System类成为Java程序中非常有用的工具。

三，Runtime

（一）Runtime 概述

Java的Runtime类是Java的核心类库的一部分，它为Java提供了一个接口，使得Java应用程序能够与底层操作系统进行交互。Runtime类提供了一些方法，使Java应用程序能够调用操作系统级别的功能。

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

1. 创建新的进程：Runtime类提供了exec()方法，可以用于创建新的进程来执行外部命令或程序。这些方法接受字符串或字符串数组作为参数，表示要执行的命令或程序的路径和参数。
2. 内存管理：Runtime类提供了一些方法来管理Java应用程序的内存。例如，totalMemory()方法返回Java虚拟机中的总内存量，freeMemory()方法返回可用内存量，maxMemory()方法返回Java虚拟机可以使用的最大内存量。
3. 与操作系统交互：Runtime类提供了一些方法来与操作系统交互。例如，getenv()方法可以获取指定环境变量的值，getRuntime()方法返回当前Java虚拟机的Runtime对象，runFinalization()方法运行所有待处理的终结器，等等。
4. 垃圾回收：Runtime类提供了gc()方法，用于请求Java虚拟机执行垃圾回收。这可以用于手动管理Java应用程序的内存。

注意：由于Runtime类是与底层操作系统交互的核心类，因此在使用Runtime类时需要谨慎处理，以避免出现安全问题和资源泄漏问题。

（二）Runtime 的常用方法

Runtime类提供了许多方法，其中一些常用的方法如下：

1. public static Runtime getRuntime()

public static Runtime getRuntime()是Java的Runtime类的一个静态方法，它返回与当前Java应用程序相关的Runtime对象。这个方法是单例模式的实现，确保只有一个Runtime实例被创建，并且可以通过调用该方法来获取该实例。

以下是一个使用getRuntime()方法的简单示例，演示如何使用Runtime对象来执行系统命令：

import java.io.*;

public class RuntimeExample {
    public static void main(String[] args) {
        try {
            Runtime runtime = Runtime.getRuntime();
            Process process = runtime.exec("notepad.exe"); // 执行系统命令
            InputStream inputStream = process.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

上述示例使用getRuntime()方法获取Runtime对象，并调用exec()方法执行系统命令"notepad.exe"。然后，通过获取进程的输入流，可以读取命令执行后的输出结果。

注意事项：

1. Runtime类是与底层操作系统交互的核心类，因此在使用Runtime类时需要谨慎处理，以避免出现安全问题和资源泄漏问题。
2. 在使用exec()方法执行外部命令时，应该始终处理可能抛出的异常，以避免程序出现错误。
3. 当Java虚拟机关闭时，所有通过Runtime类创建的进程可能不会自动关闭。为了避免资源泄漏，应该在使用完Runtime对象后手动关闭相关进程。

2. public Process exec(String command)

public Process exec(String command) 是 Java 的 Runtime 类的一个方法，用于在单独的进程中执行指定的字符串命令，并返回一个表示该进程的 Process 对象。

方法参数：

• command：一个字符串，表示要执行的命令字符串。

返回值：

• 一个 Process 对象，表示新进程的执行结果。

使用该方法可以在单独的进程中执行指定的命令。通过返回的 Process 对象，可以获取进程的输出、等待进程执行完成、处理进程的输入等。以下是一个简单的示例：

Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec("ls");

上述示例使用 Runtime 对象调用 exec() 方法执行 “ls” 命令，并返回一个表示该进程的 Process 对象。通过该对象可以进一步处理进程的输出。

3. public Process exec(String[] cmdarray)

public Process exec(String[] cmdarray) 是 Java 的 Runtime 类的一个方法，用于在单独的进程中执行字符串数组中的命令，并返回一个表示该进程的 Process 对象。

方法参数：

• cmdarray：一个字符串数组，表示要执行的命令及其参数。

返回值：

• 一个 Process 对象，表示新进程的执行结果。

使用该方法可以在单独的进程中执行命令及其参数。通过返回的 Process 对象，可以获取进程的输出、等待进程执行完成、处理进程的输入等。以下是一个简单的示例：

String[] cmdarray = {"ls", "-l"};
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec(cmdarray);

上述示例使用 Runtime 对象调用 exec() 方法执行 “ls -l” 命令，并返回一个表示该进程的 Process 对象。通过该对象可以进一步处理进程的输出。

4. public Process exec(String[] cmdarray, String[] envp)

public Process exec(String[] cmdarray, String[] envp) 是 Java 的 Runtime 类的一个方法，用于在单独的进程中执行字符串数组中的命令，并使用指定的环境变量数组来设置子进程的环境变量，并返回一个表示该进程的 Process 对象。

方法参数：

• cmdarray：一个字符串数组，表示要执行的命令及其参数。
• envp：一个字符串数组，表示要传递给子进程的环境变量。

返回值：

• 一个 Process 对象，表示新进程的执行结果。

使用该方法可以在单独的进程中执行命令，并使用指定的环境变量来设置子进程的环境变量。通过返回的 Process 对象，可以获取进程的输出、等待进程执行完成、处理进程的输入等。以下是一个简单的示例：

String[] cmdarray = {"ls", "-l"};
String[] envp = {"PATH=/usr/local/bin"};
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec(cmdarray, envp);

上述示例使用 Runtime 对象调用 exec() 方法执行 “ls -l” 命令，并使用指定的环境变量数组来设置子进程的环境变量。通过返回的 Process 对象可以进一步处理进程的输出。

5. public Process exec(String command, String[] envp)

public Process exec(String command, String[] envp) 是 Java 的 Runtime 类的一个方法，用于在单独的进程中执行指定的字符串命令，并使用指定的环境变量数组来设置子进程的环境变量，并返回一个表示该进程的 Process 对象。

方法参数：

• command：一个字符串，表示要执行的命令字符串。
• envp：一个字符串数组，表示要传递给子进程的环境变量。

返回值：

• 一个 Process 对象，表示新进程的执行结果。

使用该方法可以在单独的进程中执行指定的命令，并使用指定的环境变量来设置子进程的环境变量。通过返回的 Process 对象，可以获取进程的输出、等待进程执行完成、处理进程的输入等。以下是一个简单的示例：

String command = "ls";
String[] envp = {"PATH=/usr/local/bin"};
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec(command, envp);

上述示例使用 Runtime 对象调用 exec() 方法执行 “ls” 命令，并使用指定的环境变量数组来设置子进程的环境变量。通过返回的 Process 对象可以进一步处理进程的输出。

6. public long freeMemory()

public long freeMemory() 是 Java 的 Runtime 类的一个方法，用于返回 Java 虚拟机中的空闲内存量。

返回值：

• 一个长整型数值，表示 Java 虚拟机中的空闲内存量。

使用该方法可以获取 Java 虚拟机的空闲内存量，用于性能优化和内存管理。需要注意的是，该方法返回的空闲内存量是基于 JVM 的内部统计数据，而不是物理内存的空闲量。以下是一个简单的示例：

Runtime runtime = Runtime.getRuntime();
long freeMemory = runtime.freeMemory();
System.out.println("Free memory: " + freeMemory + " bytes");

上述示例使用 Runtime 对象调用 freeMemory() 方法获取 Java 虚拟机的空闲内存量，并输出到控制台。

7. public long maxMemory()

public long maxMemory() 是 Java 的 Runtime 类的一个方法，用于返回 Java 虚拟机试图使用的最大内存量。

返回值：

• 一个长整型数值，表示 Java 虚拟机试图使用的最大内存量。

使用该方法可以获取 Java 虚拟机试图使用的最大内存量，用于性能优化和内存管理。需要注意的是，该方法返回的数值是 JVM 在启动时根据操作系统和系统配置自动设置的，不一定是物理内存的最大可用量。以下是一个简单的示例：

Runtime runtime = Runtime.getRuntime();
long maxMemory = runtime.maxMemory();
System.out.println("Max memory: " + maxMemory + " bytes");

上述示例使用 Runtime 对象调用 maxMemory() 方法获取 Java 虚拟机试图使用的最大内存量，并输出到控制台。

8. public long totalMemory()

public long totalMemory() 是 Java 的 Runtime 类的一个方法，用于返回 Java 虚拟机中的内存总量。

返回值：

• 一个长整型数值，表示 Java 虚拟机中的内存总量。

使用该方法可以获取 Java 虚拟机的内存总量，用于性能优化和内存管理。需要注意的是，该方法返回的内存总量是 JVM 在启动时根据操作系统和系统配置自动设置的，不一定是物理内存的总容量。以下是一个简单的示例：

Runtime runtime = Runtime.getRuntime();
long totalMemory = runtime.totalMemory();
System.out.println("Total memory: " + totalMemory + " bytes");

上述示例使用 Runtime 对象调用 totalMemory() 方法获取 Java 虚拟机中的内存总量，并输出到控制台。

9. public void gc()

public void gc() 是 Java 的 Runtime 类的一个方法，用于请求 Java 虚拟机执行垃圾回收。

使用该方法可以请求 JVM 回收不再使用的对象，释放内存空间，以避免内存泄漏和内存溢出等问题。需要注意的是，该方法只是发出一个请求，JVM 可能会选择忽略该请求，因为 JVM 有权自主管理内存和垃圾回收。因此，不能保证调用该方法后一定能释放内存。以下是一个简单的示例：

Runtime runtime = Runtime.getRuntime();
runtime.gc();

上述示例使用 Runtime 对象调用 gc() 方法请求 JVM 执行垃圾回收。

10. public void runFinalization()

public void runFinalization() 是 Java 的 Runtime 类的一个方法，用于运行所有待处理的终结器。

使用该方法可以调用对象的终结方法，释放对象占用的资源，回收内存空间。需要注意的是，该方法只是运行所有待处理的终结器，而不是强制执行所有的终结器。如果对象没有定义终结方法或已经执行过终结方法，则调用该方法不会产生任何效果。以下是一个简单的示例：

Runtime runtime = Runtime.getRuntime();
runtime.runFinalization();

上述示例使用 Runtime 对象调用 runFinalization() 方法运行所有待处理的终结器。

11. public void addShutdownHook(Thread hook)

public void addShutdownHook(Thread hook) 是 Java 的 Runtime 类的一个方法，用于添加一个关闭钩子。

方法参数：

• hook：一个线程对象，表示要添加的关闭钩子。

使用该方法可以在 JVM 关闭时执行一些操作，例如关闭数据库连接、保存数据等。当 JVM 接收到关闭信号（如用户按下 Ctrl + C）时，会执行所有添加的关闭钩子，并按照它们添加的顺序执行。以下是一个简单的示例：

Runtime runtime = Runtime.getRuntime();
Thread hook = new Thread(() -> {
    System.out.println("Shutting down...");
    // 关闭数据库连接、保存数据等操作
});
runtime.addShutdownHook(hook);

上述示例使用 Runtime 对象调用 addShutdownHook() 方法添加了一个关闭钩子，该钩子会在 JVM 关闭时输出一条消息，并执行一些关闭操作。

这些方法可以帮助Java应用程序执行外部命令、管理内存、处理垃圾回收等。请注意，使用Runtime类的方法需要谨慎处理，以避免出现安全问题和资源泄漏问题。

四，Object

（一）Object 概述

在Java中，Object类是所有类的基类，这意味着每个类都直接或间接地继承自Object类。Object类是在Java语言的最底层，包含了所有Java对象的基本属性和方法。

（二）Object 的构造方法

在 Java 中，Object 类是所有类的基类，它定义了一些基本的属性和方法。Object 类中有一个默认的无参构造函数，用于创建对象实例。

在 Object 类中定义了一个默认的构造方法，该构造方法没有参数，用于创建新的对象实例。当一个类没有提供构造方法时，系统会自动调用 Object 类的默认构造方法来创建对象。

以下是 Object 类构造方法的代码：

public Object() {
    // 默认构造函数
}

在创建自定义类时，如果没有提供任何构造方法，则系统默认调用 Object 类的无参构造方法来创建对象。如果需要提供自定义的构造方法，则需要在类中重写 Object 类的默认构造方法。

需要注意的是，如果一个类没有显式地提供构造方法，则系统默认调用 Object 类的默认构造方法。如果一个类提供了自己的构造方法，则系统不会自动调用父类的构造方法。在这种情况下，需要使用 super() 关键字显式地调用父类的构造方法。

（三）Object 的成员方法

除了构造方法，Object 类还定义了一些其他常用的成员方法，如下所示：

1. equals(Object obj): 比较两个对象是否相等。默认情况下，它使用“引用相等性”来判断，也就是说，如果两个引用指向同一个对象，则它们相等。但是，许多类会重写这个方法以实现“对象相等性”，即如果两个对象的内容相等，则它们相等。
2. hashCode(): 返回对象的哈希码值。在 Java 中，哈希码通常用于在散列表（如 HashMap 和 HashSet）中存储对象。
3. getClass(): 返回对象的运行时类。
4. clone(): 创建并返回此对象的一个副本。需要注意的是，这个方法只有在对象实现了 Cloneable 接口时才会被使用，否则会抛出 CloneNotSupportedException 异常。
5. toString(): 返回对象的字符串表示。对于 String 类，这个方法返回的就是字符串本身。对于其他类，这个方法通常会返回类的名称以及其哈希码的十六进制表示。
6. wait(), notify(), notifyAll(): 这些方法用于处理对象的线程锁定和通信，它们都是 Java 的内置同步机制的一部分。

除了上述成员方法，Object 类还定义了一些其他的方法和字段，如 hashCode 字段（用于存储对象的哈希码）等。需要注意的是，虽然 Object 类提供了许多有用的方法，但并不是所有的 Java 类都需要使用这些方法。对于自定义的类，可以根据需要选择使用哪些 Object 类的方法。

五，Objects

（一）Objects 概述

在Java中，Objects类是Java标准库的一部分，位于java.util包中。Objects类提供了一些静态方法，用于操作和处理对象。这些方法涵盖了对象比较、空值处理、对象转换等方面。

（二）Objects 常用方法

在Java中，Objects类是一个工具类，提供了一些常用的对象操作方法。以下是Objects类的一些常用方法：

1. equals(Object obj)

equals(Object obj) 是Java的Object类的一个方法，它用于比较两个对象是否相等。这个方法首先检查是否传递的对象obj和调用equals方法的对象是同一个对象，即比较的是引用相等性。如果它们是同一个对象，那么返回true，否则继续比较对象的值是否相等。

在Java中，默认的equals方法使用的是“引用相等性”比较，也就是说，如果两个对象的引用是同一个引用，那么它们就是相等的。但是，对于自定义的类来说，我们通常需要实现自己的equals方法来比较对象的值是否相等。

在重写equals方法时，需要遵循以下几个规则：

1. equals方法必须是公开的（public）。
2. equals方法的参数必须是Object类型。
3. equals方法必须返回一个布尔值，表示两个对象是否相等。
4. equals方法必须对任何非null的参数都能产生一个非null的结果。

在实现equals方法时，需要比较两个对象的属性值是否相等。例如，对于一个Person类，我们可能需要比较两个Person对象的姓名（name）、年龄（age）和其他属性是否都相等。如果所有属性都相等，那么这两个Person对象就是相等的。

需要注意的是，equals方法的实现应该与hashCode方法的实现相一致，以保证在使用散列表（如HashMap和HashSet）时能够正确地处理对象。

以下是equals(Object obj)方法的示例：

public class Person {
    private String name;
    private int age;

    // 构造方法、getter和setter方法省略

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof Person)) {
            return false;
        }
        Person other = (Person) obj;
        return this.name.equals(other.name) && this.age == other.age;
    }
}

在上述示例中，我们重写了Person类的equals方法，比较了两个Person对象的姓名和年龄是否都相等。需要注意的是，在比较对象时需要先判断传递的对象是否是当前对象的一个引用，如果是则返回true；接着判断传递的对象是否是当前对象所属的类的一个实例，如果不是则返回false；最后比较两个对象的属性值是否相等。

2. hashCode()

hashCode()是Java的Object类的一个方法，它用于返回对象的哈希码值。哈希码是一个整数，是根据对象的实际内容计算出来的，可以用于快速查找对象。

在Java中，每个对象都有一个默认的hashCode方法，可以根据对象的实际内容计算出一个哈希码值。这个哈希码值可以用于将对象存储在哈希表中，以便快速查找和访问对象。

需要注意的是，如果两个对象的equals方法返回true，那么它们的hashCode方法必须返回相同的值。因此，在重写equals方法时，通常也需要重写hashCode方法，以确保它们的一致性。

以下是hashCode()方法的示例：

public class Person {
    private String name;
    private int age;

    // 构造方法、getter和setter方法省略

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + name.hashCode();
        result = 31 * result + age;
        return result;
    }
}

在上述示例中，我们重写了Person类的hashCode方法，根据对象的实际内容计算出了一个哈希码值。需要注意的是，这里使用了乘法和一个素数（31）来计算哈希码，这是为了保证哈希码的分布均匀和减少冲突。

3. toString()

toString()是Java的Object类的一个方法，它用于返回对象的字符串表示。在默认情况下，Object类的toString方法返回的是对象的类名和散列码的无意义字符串表示。

对于自定义的类来说，我们通常需要实现自己的toString方法，以便返回对象的有意义的字符串表示。toString方法的实现应该能够准确地反映对象的内部状态，包括所有重要的属性值。

在重写toString方法时，需要遵循以下几个规则：

1. toString方法必须是公开的（public）。
2. toString方法的返回类型必须是String。
3. 实现toString方法时，可以使用StringBuilder或StringBuffer类来构建字符串。

以下是toString()方法的示例：

public class Person {
    private String name;
    private int age;

    // 构造方法、getter和setter方法省略

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Person{name='").append(name).append('\'');
        sb.append(", age=").append(age);
        sb.append('}');
        return sb.toString();
    }
}

在上述示例中，我们重写了Person类的toString方法，返回了对象的字符串表示。这里使用了StringBuilder类来构建字符串，并添加了对象的name属性和age属性的字符串表示。

4. requireNonNull(T value, String message)

requireNonNull(T value, String message)是Java的Objects类中的一个静态方法。它用于检查传递的参数值是否为null，如果为null，则抛出一个带有自定义错误消息的NullPointerException。

该方法的签名如下：

public static <T> T requireNonNull(T value, String message)

参数说明：

• T value：要检查的泛型参数值。
• String message：自定义的错误消息，用于在抛出NullPointerException时提供详细的错误信息。

返回值：返回传递的参数值。

使用示例：

String str = Objects.requireNonNull(getNullableString(), "The string is null");

在上述示例中，我们调用requireNonNull方法来检查从getNullableString()方法返回的字符串是否为null。如果是null，则抛出一个带有自定义错误消息"The string is null"的NullPointerException。

这个方法特别有用，因为它允许我们在传递给方法或构造函数的重要参数为null时尽早发现错误，从而提高代码的可读性和健壮性。

5. nullToEmpty(String string)

nullToEmpty(String string)是Java的Objects类中的一个静态方法。它的作用是将传入的字符串参数转换为空字符串，如果该字符串是null，则返回一个空字符串""。

该方法的签名如下：

public static String nullToEmpty(String string)

参数说明：

• String string：要转换的字符串参数。

返回值：返回转换后的字符串。如果传入的字符串是null，则返回空字符串""。

使用示例：

String str = null;
String emptyStr = Objects.nullToEmpty(str); // emptyStr的值为""

在上述示例中，我们传入了一个null值给nullToEmpty方法，它返回了一个空字符串""。这个方法可以避免在处理字符串时出现NullPointerException，因为它将null值转换为空字符串，使得代码更加健壮和易于处理。

6. copy(T original, T dest)

copy(T original, T dest)是Java的Objects类中的一个静态方法。它的作用是将原始对象的内容复制到目标对象中。

该方法的签名如下：

public static <T> void copy(T original, T dest)

参数说明：

• T original：原始对象，其内容将被复制到目标对象中。
• T dest：目标对象，其内容将被原始对象覆盖。

返回值：无返回值。

使用示例：

List<Integer> original = Arrays.asList(1, 2, 3);
List<Integer> dest = new ArrayList<>();
Objects.copy(original, dest); // dest的内容被复制为[1, 2, 3]

在上述示例中，我们使用copy方法将原始列表original的内容复制到目标列表dest中。需要注意的是，目标对象必须是一个与原始对象兼容的实例，以便能够成功地复制原始对象的内容。

7. deepEquals(Object a, Object b)

deepEquals(Object a, Object b)是Java的Objects类中的一个静态方法。它用于深度比较两个对象是否相等，包括嵌套的对象。

该方法的签名如下：

public static boolean deepEquals(Object a, Object b)

参数说明：

• Object a：要比较的对象a。
• Object b：要比较的对象b。

返回值：返回一个布尔值，表示两个对象是否深度相等。如果相等则返回true，否则返回false。

使用示例：

List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(1, 2, 3);
boolean isEqual = Objects.deepEquals(list1, list2); // isEqual的值为true

在上述示例中，我们使用deepEquals方法比较了两个列表对象list1和list2。由于这两个列表的内容完全相同，因此deepEquals方法返回了true，表示这两个列表是深度相等的。

8. T firstNonNull(T... values)

T firstNonNull(T... values)是一个Java方法，它接受一个泛型可变参数T... values，返回第一个不为null的值。

该方法的实现如下：

public static <T> T firstNonNull(T... values) {
    for (T value : values) {
        if (value != null) {
            return value;
        }
    }
    throw new NullPointerException("All values are null");
}

该方法会遍历传入的values数组，如果发现某个值不为null，则立即返回该值。如果遍历完整个数组后都没有找到不为null的值，则抛出NullPointerException异常。

这个方法在处理多个可能为null的值时非常有用，可以避免在代码中重复检查null值。

9. format(String format, Object... args)

String.format(String format, Object... args) 是Java中用于格式化字符串的静态方法。该方法接受一个格式化字符串和一个可变数量的参数，然后返回一个新的格式化字符串。

格式化字符串包含普通文本和转换规格符。转换规格符表示在字符串中的某个位置应该插入参数。例如，%d 是一个转换规格符，表示在字符串中的该位置插入一个整数。

以下是一些使用 String.format() 的示例：

String name = "John";
int age = 25;
String greeting = String.format("Hello, %s. You are %d years old.", name, age);
System.out.println(greeting); // 输出：Hello, John. You are 25 years old.

在这个例子中，%s 是一个转换规格符，表示在字符串中的该位置插入一个字符串。%d 也是一个转换规格符，表示在字符串中的该位置插入一个整数。

除了 %s 和 %d，Java 还提供了其他一些转换规格符，例如 %f（浮点数）、%c（字符）、%b（布尔值）等。可以查阅 Java 文档以获取完整的转换规格符列表。

这些方法是Java中Objects类的常用方法，可以方便地进行对象操作和管理。