【常见的常用类】（详解方法）-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_71752625/article/details/138106033

常见的常用类

前言：以下包含了Object 类、String 类、StringBuilder 类、Integer 类、BigDecimal 类、Date 类、Math类、System类的介绍及其部分方法的使用。

Object 类（所有类的父类）

1. 构造方法

Object类只有两个构造方法：

Object(): 默认构造方法，无参数。
Object(Object obj): 复制构造方法，接收一个Object类型的参数。

2. 常用方法

a. equals(Object obj)

作用：比较当前对象与指定的Object参数是否相等。
参数：Object obj - 要与此对象相比较的的对象。
返回值：如果当前对象与参数对象相等，则返回true；如果它们不相等，则返回false。
示例：

Object obj1 = new Object();
Object obj2 = new Object();

// 比较两个对象是否相等
boolean result = obj1.equals(obj2);
// 输出结果：false

b. hashCode()

作用：返回当前对象的哈希码。
参数：无
返回值：一个整数，作为对象的哈希码。
示例：

Object obj1 = new Object();
Object obj2 = new Object();

// 获取两个对象的哈希码
int hash1 = obj1.hashCode();
int hash2 = obj2.hashCode();

// 输出结果：两个对象的哈希码通常不相等

c. toString()

作用：返回一个表示该对象的字符串。
参数：无
返回值：一个字符串，表示对象的字符串表示。
示例：

Object obj = new Object();

// 获取对象的 string 表示
String str = obj.toString();

// 输出结果：通常输出对象的类名和哈希码
// 例如：java.lang.Object@15b586eb

d. getClass()

作用：返回表示该对象的Class对象。
参数：无
返回值：一个Class对象，表示对象的类。
示例：

Object obj = new Object();

// 获取对象的类对象
Class<?> clazz = obj.getClass();

// 输出结果：输出的通常是对象的类名
// 例如：java.lang.Object

e. notify()

作用：唤醒一个在等待状态中的线程。
参数：无
返回值：无
示例：

public class NotifyExample {
    public static void main(String[] args) {
        Object lock = new Object();
        
        // 创建两个线程
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1: 获取锁");
                    lock.wait(); // 进入等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: 被通知");
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2: 等待锁");
                try {
                    Thread.sleep(1000); // 等待一段时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: 通知Thread 1");
                lock.notify(); // 唤醒等待的线程
            }
        });

        // 启动线程
        t1.start();
        t2.start();
    }
}

f. notifyAll()

作用：唤醒所有在等待状态中的线程。
参数：无
返回值：无
示例：

public class NotifyAllExample {
    public static void main(String[] args) {
        Object lock = new Object();
        
        // 创建两个线程
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1: 获取锁");
                    lock.wait(); // 进入等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: 被通知");
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2: 等待锁");
                try {
                    Thread.sleep(1000); // 等待一段时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: 通知所有等待的线程");
                lock.notifyAll(); // 唤醒所有等待的线程
            }
        });

        // 启动线程
        t1.start();
        t2.start();
    }
}

g. wait()

作用：让当前线程进入等待状态，直到另一个线程调用notify()或notifyAll()。
参数：无
返回值：无，此方法在等待状态中被中断时会抛出InterruptedException。
示例：

public class WaitExample {
    public static void main(String[] args) {
        Object lock = new Object();
        
        // 创建一个线程
        Thread t = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread: 获取锁");
                                        lock.wait(); // 进入等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread: 被唤醒");
            }
        });

        // 启动线程
        t.start();
        
        // 主线程等待一段时间后释放锁
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock) {
            lock.notify(); // 唤醒等待的线程
        }
    }
}

h. wait(long timeout)

作用：让当前线程进入等待状态，直到另一个线程调用notify()或notifyAll()，或者指定的等待时间过去。
参数：long timeout - 在进入等待状态之前，愿意等待的最长时间（以毫秒为单位）。
返回值：无，如果在指定时间内没有接收到通知，方法将返回。
示例：

public class WaitTimeoutExample {
    public static void main(String[] args) {
        Object lock = new Object();
        
        // 创建一个线程
        Thread t = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread: 获取锁");
                    lock.wait(1000); // 等待最多1000毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread: 被唤醒或超时");
            }
        });

        // 启动线程
        t.start();
        
        // 主线程等待一段时间后释放锁
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock) {
            lock.notify(); // 唤醒等待的线程
        }
    }
}

i. wait(long timeout, int nanos)

作用：让当前线程进入等待状态，直到另一个线程调用notify()或notifyAll()，或者指定的等待时间过去。
参数：long timeout - 在进入等待状态之前，愿意等待的最长时间（以毫秒为单位）；int nanos - 额外的等待时间（以纳秒为单位），最多可以 WaitTime + nanos 毫秒。
返回值：无，如果在指定时间内没有接收到通知，方法将返回。
请注意，wait()、notify()和notifyAll()方法通常用于多线程编程中，用于线程之间的通信。当一个线程调用wait()方法时，它会进入等待状态，直到另一个线程调用notify()或notifyAll()方法，这时等待的线程才会被唤醒。
示例：

public class WaitTimeoutNanosExample {
    public static void main(String[] args) {
        Object lock = new Object();
        
        // 创建一个线程
        Thread t = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread: 获取锁");
                    lock.wait(1000, 500000000); // 等待最多1000毫秒，加上500毫秒的额外时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread: 被唤醒或超时");
            }
        });

        // 启动线程
        t.start();
        
        // 主线程等待一段时间后释放锁
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock) {
            lock.notify(); // 唤醒等待的线程
        }
    }
}

3. 覆盖规则

当你在子类中覆盖equals()、hashCode()和toString()方法时，需要遵守以下规则：

如果覆盖了equals()，则必须同时覆盖hashCode()。
如果覆盖了hashCode()，则建议同时覆盖equals()。
toString()方法可以单独覆盖，没有特别的规则限制。

4. 类的继承

所有的Java类（除了Object类本身）都是Object的子类。这意味着，每个类都继承了Object类的所有方法和属性。

5. 用途

Object类是Java面向对象编程的基础，它的方法为对象提供了基本的操作和属性，如相等性测试、哈希码生成和字符串表示等。

String 类

String类是Java编程语言中的一个重要类，它代表字符串，是char数组的序列化形式。String类在java.lang包中定义，因此不需要导入即可直接使用。String对象是不可变的，这意味着一旦创建了一个String对象，就不能更改它包含的字符序列。

构造方法

String类提供了一系列构造方法来创建字符串对象，以下是一些常用的构造方法：

String(): 构造一个空字符串。
String(char[] chars): 使用字符数组中的字符来构造字符串。
String(char[] chars, int startIndex, int numChars): 使用字符数组中的一部分来构造字符串。
String(String original): 使用已有的String对象来构造新的字符串。
String(byte[] bytes): 使用字节数组来构造字符串，通常用于编码转换。

常用方法

a. char charAt(int index)

作用：返回指定索引位置的字符。
参数：索引位置。
返回值：该位置的字符。
示例：

String str = "Hello, World!";
char ch = str.charAt(7);

// 输出结果：ch 的值为 'W'

b. int compareTo(String anotherString)

作用：将指定字符串与当前字符串进行比较。
参数：另一个字符串。
返回值：比较结果，负数表示当前字符串小于参数字符串，零表示相等，正数表示当前字符串大于参数字符串。
示例：

String str1 = "Apple";
String str2 = "Banana";

int result = str1.compareTo(str2);

// 输出结果：result 的值为 -9
// 因为 'A' 的 ASCII 码是 65，'B' 的 ASCII 码是 66，所以 str1 < str2

c. String concat(String str)

作用：将指定字符串连接到当前字符串的末尾。
参数：要连接的字符串。
返回值：连接后的字符串。
示例：

String str1 = "Hello";
String str2 = "World";

String concatenated = str1.concat(str2);

// 输出结果：concatenated 的值为 "HelloWorld"

d. int length()

作用：返回字符串的长度（字符数）。
返回值：字符串的长度。
示例：

String str = "Java";

int length = str.length();

// 输出结果：length 的值为 4

e. String substring(int beginIndex)

作用：返回一个新字符串，它是从beginIndex到原始字符串末尾的一个子字符串。
参数：子字符串的开始索引。
返回值：新的子字符串。
示例：

String str = "Hello, World!";

String subStr = str.substring(7);

// 输出结果：subStr 的值为 "World!"

f. String substring(int beginIndex, int endIndex)

作用：返回一个新字符串，它是从beginIndex到endIndex-1的一个子字符串。
参数：子字符串的开始和结束索引。
返回值：新的子字符串。
示例：

String str = "Hello, World!";

String subStr = str.substring(7, 12);

// 输出结果：subStr 的值为 "World"

g. boolean equals(Object anObject)

作用：判断字符串是否与指定的对象相等。
参数：要比较的对象。
返回值：如果字符串相等，返回true；否则，返回false。
示例：

String str1 = "Hello";
String str2 = new String("Hello");

boolean result = str1.equals(str2);

// 输出结果：result 的值为 false
// 因为 str1 和 str2 虽然内容相同，但它们是不同的对象

h. boolean equalsIgnoreCase(String anotherString)

作用：判断两个字符串是否相等，不考虑大小写。
参数：另一个字符串。
返回值：如果字符串相等，返回true；否则，返回false。
示例：

String str1 = "Hello";
String str2 = "hello";

boolean result = str1.equalsIgnoreCase(str2);

// 输出结果：result 的值为 true
// 因为这两个字符串在不考虑大小写的情况下内容相同

i. int hashCode()

作用：返回字符串的哈希码。
返回值：字符串的哈希码。
示例：

String str = "Hello";

int hashCode = str.hashCode();

// 输出结果：hashCode 的值为 7013301
// 注意：每次调用 hashCode() 方法时，可能会有不同的结果

j. String toString()

作用：返回字符串的字符串表示。
返回值：字符串的字符串表示。
示例：

String str = new String("Hello");

String stringRepresentation = str.toString();

// 输出结果：stringRepresentation 的值为 "Hello"

字符串连接

在Java中，字符串连接可以通过+运算符实现，也可以使用String类的concat()方法实现。两种方式的效果是一样的，但是使用+运算符时，如果操作数中有一个是null，则会抛出NullPointerException。

总结

String类是Java中非常基础且重要的类，它的许多方法都涉及字符串的操作，如创建、修改、比较和转换等。由于String对象是不可变的，因此它们在多线程环境中是安全的，可以直接作为常量使用。但是，不可变性也意味着一旦创建了字符串，就不能修改它，这可能会导致一些性能问题，特别是在进行大量字符串操作时。在这种情况下，可以考虑使用StringBuilder或StringBuffer类，这些类提供了可变的字符串构建器。

StringBuilder 类

StringBuilder 类是 Java 编程语言中的一个可变字符序列类，它提供了对字符序列进行修改的方法。StringBuilder 是非线程安全的，因为它的方法不保证是原子操作，所以在单线程环境中它的性能要优于 StringBuffer。

StringBuilder 类位于 java.lang 包中，与 String 类一样，它也提供了很多方法来操作字符串。但是与 String 类不同的是，StringBuilder 对象是可变的，这意味着你可以修改它们包含的字符序列。

构造方法

StringBuilder()

作用：构造一个初始为空字符串的 StringBuilder 对象。
参数：无
返回值：无（构造方法不返回值）
示例：

StringBuilder sb = new StringBuilder();
System.out.println(sb.toString()); // 输出： ""

StringBuilder(String str)

作用：构造一个初始化为指定字符串的 StringBuilder 对象。
参数：str - 要初始化的字符串。
返回值：无（构造方法不返回值）
示例：

StringBuilder sb = new StringBuilder("Hello");
System.out.println(sb.toString()); // 输出： "Hello"

常用方法

void append(char c)

作用：在当前 StringBuilder 对象的字符序列末尾添加指定的字符。
参数：c - 要添加的字符。
返回值：无（该方法不返回值）
示例：

StringBuilder sb = new StringBuilder("Hello");
sb.append('!');
System.out.println(sb.toString()); // 输出： "Hello!"

void append(char[] str)

作用：在当前 StringBuilder 对象的字符序列末尾添加指定字符数组中的字符。
参数：str - 要添加的字符数组。
返回值：无（该方法不返回值）
示例：

StringBuilder sb = new StringBuilder("Hello");
char[] chars = {'W', 'o', 'r', 'l', 'd'};
sb.append(chars);
System.out.println(sb.toString()); // 输出： "HelloWorld"

void append(String str)

作用：在当前 StringBuilder 对象的字符序列末尾添加指定的字符串。
参数：str - 要添加的字符串。
返回值：无（该方法不返回值）
示例：

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
System.out.println(sb.toString()); // 输出： "Hello World"

void delete(int start, int end)

作用：删除指定索引范围内的字符。
参数：
- start - 开始索引（包含此索引位置的字符）。
- end - 结束索引（不包含此索引位置的字符）。
返回值：无（该方法不返回值）
示例：

StringBuilder sb = new StringBuilder("HelloWorld");
sb.delete(6, 11);
System.out.println(sb.toString()); // 输出： "Hello"

void insert(int index, char c)

作用：在指定索引位置插入指定的字符。
参数：
- index - 要插入字符的索引位置。
- c - 要插入的字符。
返回值：无（该方法不返回值）
示例：

StringBuilder sb = new StringBuilder("HelloWorld");
sb.insert(5, 'J');
System.out.println(sb.toString()); // 输出： "HelloJWorld"

int length()

作用：返回 StringBuilder 对象的字符序列长度。
参数：无
返回值：返回字符序列的长度。
示例：

StringBuilder sb = new StringBuilder("HelloWorld");
int length = sb.length();
System.out.println(length); // 输出： 10

char charAt(int index)

作用：返回指定索引位置的字符。
参数：index - 要查询的字符的索引位置。
返回值：返回指定索引位置的字符。
示例：

StringBuilder sb = new StringBuilder("HelloWorld");
char ch = sb.charAt(5);
System.out.println(ch);  // 输出： 'W'

void setCharAt(int index, char ch)

作用：设置指定索引位置的字符。
参数：
- index - 要设置的字符的索引位置。
- ch - 要设置的字符。
返回值：无（该方法不返回值）
示例：

StringBuilder sb = new StringBuilder("HelloWorld");
sb.setCharAt(5, 'X');
System.out.println(sb.toString()); // 输出： "HelloXWorld"

String toString()

作用：返回 StringBuilder 对象的字符串表示。
参数：无
返回值：返回 StringBuilder 对象的字符串表示。
示例：

StringBuilder sb = new StringBuilder("HelloWorld");
String str = sb.toString();
System.out.println(str); // 输出： "HelloWorld"

Integer 类

Integer 类是 Java 中的一个包装类，用于在程序中处理整数。它提供了一系列的方法，用于执行常见的数值操作和类型转换。下面是一些常用 Integer
类方法的作用、参数、返回值和示例：

a. int intValue()

作用：返回包装的整数值。
参数：无。
返回值：包装的整数值。

Integer num = new Integer(10);
int value = num.intValue();
// 输出结果：value 的值为 10

b. Integer valueOf(int i)

作用：返回一个表示指定整数值的 Integer 对象。
参数：一个整数值。
返回值：一个 Integer 对象。

int intValue = 10;
Integer num = Integer.valueOf(intValue);
// 输出结果：num 的值为 10

c. int compareTo(Integer anotherInteger)

作用：比较两个 Integer 对象的值。
参数：另一个 Integer 对象。
返回值：如果调用对象的值小于、等于或大于参数的值，返回 -1、0 或 1。

Integer num1 = 10;
Integer num2 = 20;
int result = num1.compareTo(num2);
// 输出结果：result 的值为 -1

d. int compareTo(int anotherInt)

作用：比较包装的整数值与另一个整数值。
参数：另一个整数值。
返回值：如果调用对象的值小于、等于或大于参数的值，返回 -1、0 或 1。

Integer num1 = new Integer(10);
int result = num1.compareTo(20);
// 输出结果：result 的值为 -1

e. boolean equals(Object obj)

作用：比较两个 Integer 对象的值是否相等。
参数：另一个对象。
返回值：如果两个对象相等，返回 true；否则，返回 false。

Integer num1 = 10;
Integer num2 = new Integer(10);
boolean result = num1.equals(num2);
// 输出结果：result 的值为 true

f. boolean equals(int value)

作用：比较包装的整数值与另一个整数值是否相等。
参数：另一个整数值。
返回值：如果两个值相等，返回 true；否则，返回 false。

Integer num1 = new Integer(10);
int num2 = 10;
boolean result = num1.equals(num2);
// 输出结果：result 的值为 true

g. int hashCode()

作用：返回整数的哈希码。
参数：无。
返回值：整数的哈希码。

Integer num = 10;
int hashCode = num.hashCode();
// 输出结果：hashCode 的值为 10

h. int parseInt(String s)

作用：将字符串转换为整数。
参数：一个字符串。
返回值：转换后的整数。

String numStr = "10";
int num = Integer.parseInt(numStr);
// 输出结果：num 的值为 10

i. Integer parseInteger(String s)

作用：将字符串转换为 Integer 对象。
参数：一个字符串。
返回值：转换后的 Integer 对象，如果字符串不能转换为整数，则返回 null。

String numStr = "10";
Integer num = Integer.parseInteger(numStr);
// 输出结果：num 的值为 10

请注意，上述示例代码需要在Java环境中运行以观察效果。在这些示例中，intValue() 方法用于获取Integer 对象的整数值，valueOf() 方法用于将整数转换为 Integer 对象，compareTo() 方法用于比较两个 Integer 对象的值，equals() 方法用于判断两个 Integer 对象或整数值是否相等，hashCode() 方法用于获取整数的哈希码，parseInt() 方法用于将字符串解析为整数，而 parseInteger() 方法用于将字符串解析为 Integer 对象。
下面是一些其他 Integer 类的方法示例：

j. static Integer valueOf(String s)

作用：返回一个表示指定字符串的 Integer 对象。
参数：一个字符串。
返回值：一个 Integer 对象。

String numStr = "10";
Integer num = Integer.valueOf(numStr);
// 输出结果：num 的值为 10

k. static Integer parseInt(String s, int radix)

作用：将字符串解析为整数。
参数：一个字符串和一个进制基数（范围从 2 到 36）。
返回值：转换后的整数。

String numStr = "10";
int num = Integer.parseInt(numStr, 10);
// 输出结果：num 的值为 10

l. int compare(Integer a, Integer b)

作用：比较两个 Integer 值。
参数：两个 Integer 对象。
返回值：如果 a < b，返回 -1；如果 a == b，返回 0；如果 a > b，返回 1。

Integer num1 = 10;
Integer num2 = 20;
int result = Integer.compare(num1, num2);
// 输出结果：result 的值为 -1

m. static int highestOneBit(int i)

作用：返回最接近 i 的 2 的幂。
参数：一个整数。
返回值：最接近 i 的 2 的幂。

int num = 10;
int highestOneBit = Integer.highestOneBit(num);
// 输出结果：highestOneBit 的值为 8

n. static int lowestOneBit(int i)

作用：返回最接近 i 的 2 的幂。
参数：一个整数。
返回值：最接近 i 的 2 的幂。

int num = 10;
int lowestOneBit = Integer.lowestOneBit(num);
// 输出结果：lowestOneBit 的值为 2

o. static int numberOfLeadingZeros(int i)

作用：返回前导 0 的数量。
参数：一个整数。
返回值：前导 0 的数量。

int num = 0b00001010;
int leadingZeros = Integer.numberOfLeadingZeros(num);
// 输出结果：leadingZeros 的值为 2

p. static int numberOfTrailingZeros(int i)

作用：返回尾随 0 的数量。
参数：一个整数。
返回值：尾随 0 的数量。

int num = 0b010100;
int trailingZeros = Integer.numberOfTrailingZeros(num);
// 输出结果：trailingZeros 的值为 2

请注意，上述示例代码需要在Java环境中运行以观察效果。在这些示例中，valueOf() 方法用于将字符串转换为 Integer 对象，parseInt() 方法用于将字符串解析为整数，compare() 方法用于比较两个 Integer 对象的值，highestOneBit() 和 lowestOneBit() 方法用于获取最接近的 2 的幂，而 numberOfLeadingZeros() 和 `numberOfTrailingZeros()方法用于计算前导零和尾随零的数量。

q. static int bitCount(int i)

作用：计算整数中设置的位数量。
参数：一个整数。
返回值：整数中设置的位的数量。

int num = 0b101010;
int bitCount = Integer.bitCount(num);
// 输出结果：bitCount 的值为 4

r. static int reverse(int i)

作用：返回整数的位反转。
参数：一个整数。
返回值：位反转后的整数。

int num = 0b101010;
int reverse = Integer.reverse(num);
// 输出结果：reverse 的值为 0b010101

s. static int highestOneBit(int i)

作用：返回最接近 i 的最大 2 的幂。
参数：一个整数。
返回值：最接近 i 的最大 2 的幂。

int num = 15;
int highestOneBit = Integer.highestOneBit(num);
// 输出结果：highestOneBit 的值为 8

t. static int lowestOneBit(int i)

作用：返回最接近 i 的最小 2 的幂。
参数：一个整数。
返回值：最接近 i 的最小 2 的幂。

int num = 15;
int lowestOneBit = Integer.lowestOneBit(num);
// 输出结果：lowestOneBit 的值为 1

u. static int numberOfLeadingZeros(int i)

作用：返回整数二进制表示中前导零的数量。
参数：一个整数。
返回值：前导零的数量。

int num = 0b0000000010101010;
int numberOfLeadingZeros = Integer.numberOfLeadingZeros(num);
// 输出结果：numberOfLeadingZeros 的值为 7

v. static int numberOfTrailingZeros(int i)

作用：返回整数二进制表示中尾随零的数量。
参数：一个整数。
返回值：尾随零的数量。

int num = 0b0000101000000000;
int numberOfTrailingZeros = Integer.numberOfTrailingZeros(num);
// 输出结果：numberOfTrailingZeros 的值为 4

w. static int bitCount(int i)

作用：计算整数中设置的位数量。
参数：一个整数。
返回值：整数中设置的位的数量。

int num = 0b1010101010101010;
int bitCount = Integer.bitCount(num);
// 输出结果：bitCount 的值为 10

x. static int reverse(int i)

作用：返回整数的位反转。
参数：一个整数。
返回值：位反转后的整数。

int num = 0b1010101010101010;
int reverse = Integer.reverse(num);
// 输出结果：reverse 的值为 0b0101010101010101

这些方法大多数都是 static 的，这意味着它们可以直接通过类名调用，而不需要创建 Integer 对象的实例。这些方法提供了对整数各种操作的便捷封装，使得常见的整数操作变得更加简单和高效。

BigDecimal 类

BigDecimal 类是 Java 中的一个用于精确控制小数的类。用于解决浮点型运算精度损失的问题。它提供了许多方法来执行常见的数值操作，如加、减、乘、除，以及设置 scale（小数点后的位数）等。下面是一些常用的 BigDecimal 类方法的作用、参数、返回值和示例：

a. BigDecimal(String val)

作用：根据字符串值创建一个 BigDecimal 对象。
参数：一个字符串表示的数值。
返回值：一个新的 BigDecimal 对象。

String value = "123.456";
BigDecimal bd = new BigDecimal(value);
// 输出结果：bd 的值为 123.456

b. BigDecimal(double val)

作用：根据 double 值创建一个 BigDecimal 对象。
参数：一个 double 值。
返回值：一个新的 BigDecimal 对象。

double value = 123.456;
BigDecimal bd = new BigDecimal(value);
// 输出结果：bd 的值为 123.456

c. BigDecimal(int val)

作用：根据整数值创建一个 BigDecimal 对象。
参数：一个整数值。
返回值：一个新的 BigDecimal 对象。

int value = 123;
BigDecimal bd = new BigDecimal(value);
// 输出结果：bd 的值为 123

d. BigDecimal add(BigDecimal val)

作用：返回两个 BigDecimal 对象的和大 BigDecimal 对象。
参数：另一个 BigDecimal 对象。
返回值：和大 BigDecimal 对象。

BigDecimal bd1 = new BigDecimal("123.456");
BigDecimal bd2 = new BigDecimal("78.910");
BigDecimal sum = bd1.add(bd2);
// 输出结果：sum 的值为 202.366

e. BigDecimal subtract(BigDecimal val)

作用：返回两个 BigDecimal 对象的差和 BigDecimal 对象。
参数：另一个 BigDecimal 对象。
返回值：差和 BigDecimal 对象。

BigDecimal bd1 = new BigDecimal("123.456");
BigDecimal bd2 = new BigDecimal("78.910");
BigDecimal difference = bd1.subtract(bd2);
// 输出结果：difference 的值为 44.546

f. BigDecimal multiply(BigDecimal val)

作用：返回两个 BigDecimal 对象的积和 BigDecimal 对象。
参数：另一个 BigDecimal 对象。
返回值：积和 BigDecimal 对象。

BigDecimal bd1 = new BigDecimal("123.456");
BigDecimal bd2 = new BigDecimal("78.910");
BigDecimal product = bd1.multiply(bd2);
// 输出结果：product 的值为 9682.8776

g. BigDecimal divide(BigDecimal val, int scale, RoundingMode roundingMode)

作用：返回两个 BigDecimal 对象的商，并指定小数点后的位数和舍入模式。
参数：另一个 BigDecimal 对象，小数点后的位数，舍入模式。
返回值：商和 BigDecimal 对象。

BigDecimal bd1 = new BigDecimal("123.456");
BigDecimal bd2 = new BigDecimal("78.910");
BigDecimal quotient = bd1.divide(bd2, 2, RoundingMode.HALF_UP);

// 输出结果：quotient 的值为 1.56

h. BigDecimal setScale(int newScale, RoundingMode roundingMode)

作用：设置 BigDecimal 对象的小数点后位数，并指定舍入模式。
参数：新的小数点后位数，舍入模式。
返回值：调整小数点后位数的 BigDecimal 对象。

BigDecimal bd = new BigDecimal("123.456");
bd = bd.setScale(2, RoundingMode.HALF_UP);
// 输出结果：bd 的值为 123.46

i. int compareTo(BigDecimal val)

作用：比较两个 BigDecimal 对象的值。
参数：另一个 BigDecimal 对象。
返回值：如果此 BigDecimal 值小于、等于或大于参数值，则返回 -1、0 或 1。

BigDecimal bd1 = new BigDecimal("123.456");
BigDecimal bd2 = new BigDecimal("123.456");
int compareResult = bd1.compareTo(bd2);
// 输出结果：compareResult 的值为 0

j. BigDecimal max(BigDecimal val1, BigDecimal val2)

作用：返回两个 BigDecimal 对象中的最大值。
参数：两个 BigDecimal 对象。
返回值：最大值的 BigDecimal 对象。

BigDecimal bd1 = new BigDecimal("123.456");
BigDecimal bd2 = new BigDecimal("78.910");
BigDecimal maxVal = BigDecimal.max(bd1, bd2);
// 输出结果：maxVal 的值为 123.456

k. BigDecimal min(BigDecimal val1, BigDecimal val2)

作用：返回两个 BigDecimal 对象中的最小值。
参数：两个 BigDecimal 对象。
返回值：最小值的 BigDecimal 对象。

BigDecimal bd1 = new BigDecimal("123.456");
BigDecimal bd2 = new BigDecimal("78.910");
BigDecimal minVal = BigDecimal.min(bd1, bd2);
// 输出结果：minVal 的值为 78.910

l. BigDecimal pow(double exponent)

作用：返回 BigDecimal 的幂运算结果。
参数：一个 double 类型的指数。
返回值：幂运算结果的 BigDecimal 对象。

BigDecimal bd = new BigDecimal("2");
BigDecimal powResult = bd.pow(3.0);
// 输出结果：powResult 的值为 8

m. BigDecimal abs()

作用：返回 BigDecimal 对象的绝对值。
参数：无。
返回值：绝对值的 BigDecimal 对象。

BigDecimal bd = new BigDecimal("-123.456");
BigDecimal absResult = bd.abs();
// 输出结果：absResult 的值为 123.456

n. BigDecimal negate()

作用：返回 BigDecimal 对象的相反数。
参数：无。
返回值：相反数的 BigDecimal 对象。

BigDecimal bd = new BigDecimal("123.456");
BigDecimal negateResult = bd.negate();
// 输出结果：negateResult 的值为 -123.456

o. BigDecimal stripTrailingZeros()

作用：移除 BigDecimal 对象中末尾的零。
参数：无。
返回值：移除末尾零后的 BigDecimal 对象。

BigDecimal bd = new BigDecimal("123.45600");
BigDecimal stripped = bd.stripTrailingZeros();
// 输出结果：stripped 的值为 123.456

p. BigDecimal round(int newScale, RoundingMode roundingMode)

作用：将 BigDecimal 对象四舍五入到指定的小数点后位数。
参数：新的小数点后位数，舍入模式。
返回值：四舍五入后的 BigDecimal 对象。

BigDecimal bd = new BigDecimal("123.456");
BigDecimal rounded = bd.round(2, RoundingMode.HALF_UP);
// 输出结果：rounded 的值为 123.46

这些方法提供了 BigDecimal 类的基本操作，可以用来进行精确的数值计算。在使用这些方法时，需要注意参数的合法性，以及舍入模式的选择，以确保计算结果的准确性。

Date 类

Date 类是 Java 中用于表示日期的类。它提供了多种方法来操作日期，如获取年、月、日、小时、分钟、秒等，以及设置和格式化日期。下面是一些常用的 Date 类方法的作用、参数、返回值和示例：

a. Date()

作用：构造一个 Date 对象，表示当前时间。
参数：无。
返回值：无。

Date date = new Date();
// 输出结果：无，但当前时间的日期和时间被存储在 date 对象中

b. Date(long milliseconds)

作用：根据自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数来构造一个 Date 对象。
参数：一个长整型数值，表示自 1970 年 1 月 1 日以来的毫秒数。
返回值：无。

Date date = new Date(1615282400000L);
// 输出结果：无，但给定的时间戳被存储在 date 对象中

c. getTime()

作用：获取自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数。
参数：无。
返回值：一个长整型数值，表示自 1970 年 1 月 1 日以来的毫秒数。

Date date = new Date();
long time = date.getTime();
// 输出结果：time 包含了 date 对象表示的日期的毫秒数

d. getYear()

作用：获取年份（例如，2020）。
参数：无。
返回值：一个整型数值，表示年份。

Date date = new Date();
int year = date.getYear();
// 输出结果：year 包含了 date 对象表示的年份

e. getMonth()

作用：获取月份（0-11，其中 0 表示一月）。
参数：无。
返回值：一个整型数值，表示月份。

Date date = new Date();
int month = date.getMonth();
// 输出结果：month 包含了 date 对象表示的月份

f. getDate()

作用：获取日（1-31）。
参数：无。
返回值：一个整型数值，表示日。

Date date = new Date();
int day = date.getDate();
// 输出结果：day 包含了 date 对象表示的日

g. getHours()

作用：获取小时（0-23）。
参数：无。
返回值：一个整型数值，表示小时。

Date date = new Date();
int hours = date.getHours();
// 输出结果：hours 包含了 date 对象表示的小时

h. getMinutes()

作用：获取分钟（0-59）。
参数：无。
返回值：一个整型数值，表示分钟。

Date date = new Date();
int minutes = date.getMinutes();
// 输出结果：minutes 包含了 date 对象表示的分钟

i. getSeconds()

作用：获取秒（0-59）。
参数：无。
返回值：一个整型数值，表示秒。

Date date = new Date();
int seconds = date.getSeconds();
// 输出结果：seconds 包含了 date 对象表示的秒

j. setTime(long milliseconds)

作用：根据自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数来设置 Date 对象的时间。

参数：一个长整型数值，表示自 1970 年 1 月 1 日以来的毫秒数。

返回值：无。

Date date = new Date();
date.setTime(1615282400000L);
// 输出结果：无，但 date 对象的时间被设置为给定的时间戳

k. setYear(int year)

作用：设置年份。
参数：一个整型数值，表示年份。
返回值：无。

Date date = new Date();
date.setYear(2020);
// 输出结果：无，但 date 对象的年份被设置为 2020

l. setMonth(int month)

作用：设置月份。
参数：一个整型数值，表示月份（0-11，其中 0 表示一月）。
返回值：无。

Date date = new Date();
date.setMonth(0); // 表示一月
// 输出结果：无，但 date 对象的月份被设置为一月

m. setDate(int date)

作用：设置日。
参数：一个整型数值，表示日（1-31）。
返回值：无。

Date date = new Date();
date.setDate(1); // 表示一日
// 输出结果：无，但 date 对象的日被设置为一日

n. setHours(int hours)

作用：设置小时。
参数：一个整型数值，表示小时（0-23）。
返回值：无。

Date date = new Date();
date.setHours(0); // 表示零时
// 输出结果：无，但 date 对象的小时被设置为零时

o. setMinutes(int minutes)

作用：设置分钟。
参数：一个整型数值，表示分钟（0-59）。
返回值：无。

Date date = new Date();
date.setMinutes(0); // 表示零分
// 输出结果：无，但 date 对象的分钟被设置为零分

p. setSeconds(int seconds)

作用：设置秒。
参数：一个整型数值，表示秒（0-59）。
返回值：无。

Date date = new Date();
date.setSeconds(0); // 表示零秒
// 输出结果：无，但 date 对象的秒被设置为零秒

q. toString()

作用：返回日期和时间的字符串表示形式。
参数：无。
返回值：一个字符串，表示日期和时间。

Date date = new Date();
String dateString = date.toString();
// 输出结果：dateString 包含了 date 对象的字符串表示形式，例如 "Thu Feb 10 15:42:07 GMT+08:00 2023"

这些方法允许你创建 Date 对象，获取和设置日期和时间的一部分，以及将日期和时间转换为字符串表示。请注意，Date 类已经被 Java 的新日期和时间 API （如 java.time 包中的 LocalDate、LocalTime 和 LocalDateTime 类）所取代。在新的 API 中，Date 类已经被弃用，建议使用新的类来处理日期和时间。

由于 Date 类已经被新的 java.time 包中的类所取代，如 LocalDate、LocalTime 和 LocalDateTime，以及其他相关类，如 ZonedDateTime、OffsetDateTime 等，下面将介绍这些新类的一些基本用法。

LocalDate

作用：表示日期，没有时间和时区信息。
参数：无。
返回值：无。

LocalDate today = LocalDate.now(); // 当前日期
LocalDate specificDate = LocalDate.of(2023, Month.FEBRUARY, 29); // 特定日期
// 输出结果：打印当前日期或特定日期

LocalTime

作用：表示时间，没有日期和时区信息。
参数：无。
返回值：无。

LocalTime now = LocalTime.now(); // 当前时间
LocalTime specificTime = LocalTime.of(13, 45, 20); // 特定时间
// 输出结果：打印当前时间或特定时间

LocalDateTime

作用：表示日期和时间，没有时区信息。
参数：无。
返回值：无。

LocalDateTime now = LocalDateTime.now(); // 当前日期和时间
LocalDateTime specificDateTime = LocalDateTime.of(2023, Month.FEBRUARY, 29, 13, 45, 20); // 特定日期和时间
// 输出结果：打印当前日期和时间或特定日期和时间

ZonedDateTime

作用：表示带时区的日期和时间。
参数：一个时区。
返回值：无。

ZonedDateTime zonedDateTime = ZonedDateTime.now(); // 当前带时区的日期和时间
ZonedDateTime zonedDateTimeInTokyo = ZonedDateTime.now(ZoneId.of("Asia/Tokyo")); // 东京的当前带时区的日期和时间
// 输出结果：打印当前带时区的日期和时间或特定时区的日期和时间

OffsetDateTime

作用：表示带时区和偏移量的日期和时间。
参数：一个时区和一个偏移量。
返回值：无。

OffsetDateTime offsetDateTime = OffsetDateTime.now(); // 当前带时区和偏移量的日期和时间
OffsetDateTime offsetDateTimeInMST = OffsetDateTime.now(ZoneOffset.ofHours(-7)); // 山地标准时间（MST）的当前带时区和偏移量的日期和时间
// 输出结果：打印当前带时区和偏移量的日期和时间或特定时区和偏移量的日期和时间

Period

作用：表示日期之间的区间。
参数：起始日期和结束日期。
返回值：无。

LocalDate start = LocalDate.of(2023, Month.JANUARY, 1);
LocalDate end = LocalDate.of(2023, Month.JANUARY, 31);
Period period = Period.between(start, end); // 计算1月1日到1月31日的期间
// 输出结果：打印期间，例如 "2023-01-01 to 2023-01-31"

Duration

作用：表示时间之间的区间。
参数：起始时间和结束时间。
返回值：无。

LocalTime startTime = LocalTime.of(10, 0);
LocalTime endTime = LocalTime.of(15, 30);
Duration duration = Duration.between(startTime, endTime); // 计算10点到15点30分的时间间隔
// 输出结果：打印时间间隔，例如 "PT5H30M"（5小时30分钟）

这些新类提供了更多的功能和更强的类型检查，使得日期和时间的处理更加安全和大胆。它们也更好地支持了国际化，因为它们提供了用于解析和格式化日期和时间的标准化的方式。以下是一些额外的示例和信息，展示了如何使用 java.time 包中的类。

DateTimeFormatter

作用：用于格式化和解析日期时间对象。
参数：一个字符串，表示日期时间的格式。
返回值：无。

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime dateTime = LocalDateTime.now();
String formattedDateTime = dateTime.format(formatter);
// 输出结果：formattedDateTime 包含了格式化的日期时间字符串，例如 "2023-04-01 12:34:56"

ZoneId

作用：用于表示时区。
参数：一个字符串，表示时区的ID。
返回值：无。

ZoneId zoneId = ZoneId.of("America/New_York");
ZonedDateTime zonedDateTime = ZonedDateTime.now(zoneId);
// 输出结果：zonedDateTime 包含了当前在新泽西时间的日期和时间

Instant

作用：表示时间戳，通常用于记录事件发生的瞬间。
参数：无。
返回值：无。

Instant instant = Instant.now();
// 输出结果：instant 包含了当前时间的时间戳

Timestamp

作用：表示时间戳，与 Instant 类似，但通常用于表示数据库中的时间戳。
参数：无。
返回值：无。

Timestamp timestamp = Timestamp.now();
// 输出结果：timestamp 包含了当前时间的时间戳

示例代码

以下是一个简单的示例，展示了如何使用这些类来获取当前日期和时间，并将其格式化为字符串。

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class DateTimeExample {
    public static void main(String[] args) {
        // 获取当前日期
        LocalDate currentDate = LocalDate.now();
        System.out.println("当前日期： " + currentDate);
        // 获取当前时间
        LocalTime currentTime = LocalTime.now();
        System.out.println("当前时间： " + currentTime);
        // 获取当前日期和时间
        LocalDateTime currentDateTime = LocalDateTime.now();
        System.out.println("当前日期和时间： " + currentDateTime);
        // 格式化日期时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = currentDateTime.format(formatter);
        System.out.println("格式化后的日期时间： " + formattedDateTime);
    }
}

输出结果将显示当前的日期、时间和日期时间，以及一个使用自定义格式化的日期时间字符串。
请注意，java.time 包是 Java 8 引入的，如果你的项目使用的是早期版本的 Java，你可能需要使用 java.util.Calendar 类或其他相关类来处理日期和时间。

Math 类

Math 类是 Java 标准库中的一个类，它包含了一系列的静态数学方法。这些方法可以执行基本的数学运算，如加法、减法、乘法、除法等，以及对数字进行各种数学函数计算，如平方根、指数、对数等。
下面是一些 Math 类中常用的方法的详细信息：

abs(double a)

作用：返回参数的绝对值。
参数：一个 double 类型的数值。
返回值：一个 double 类型的数值，表示参数的绝对值。

double result = Math.abs(-10.5); // 结果是 10.5

sqrt(double a)

作用：返回参数的平方根。
参数：一个非负的 double 类型的数值。
返回值：一个 double 类型的数值，表示参数的平方根。

double result = Math.sqrt(25.0); // 结果是 5.0

pow(double a, double b)

作用：返回参数 a 的参数 b 次幂。
参数：两个 double 类型的数值，分别表示底数和指数。
返回值：一个 double 类型的数值，表示底数的指数次幂。

double result = Math.pow(2.0, 3.0); // 结果是 8.0

exp(double a)

作用：返回自然对数底数 e 的 a 次幂。
参数：一个 double 类型的数值。
返回值：一个 double 类型的数值，表示 e 的 a 次幂。

double result = Math.exp(1.0); // 结果是约 2.71828

log(double a)

作用：返回参数的对数。
参数：一个正的 double 类型的数值。
返回值：一个 double 类型的数值，表示参数的对数。

double result = Math.log(100.0); // 结果是约 4.60517

cos(double a)

作用：返回参数的余弦值。
参数：一个 double 类型的数值，表示弧度。
返回值：一个 double 类型的数值，表示参数的余弦值。

double result = Math.cos(Math.PI / 2); // 结果是 0.0

sin(double a)

作用：返回参数的正弦值。
参数：一个 double 类型的数值，表示弧度。
返回值：一个 double 类型的数值，表示参数的正弦值。

double result = Math.sin(Math.PI / 4); // 结果是约 0.70711

tan(double a)

作用：返回参数的正切值。
参数：一个 double 类型的数值，表示弧度。
返回值：一个 double 类型的数值，表示参数的正切值。

double result = Math.tan(Math.PI / 4); // 结果是约 1.0

round(double a)

作用：返回最接近参数的整数，如果参数是小数。
参数：一个 double 类型的数值。
返回值：一个 long 类型的数值，表示最接近参数的整数。

long result = Math.round(3.14); // 结果是 3

random()

作用：返回一个伪随机数，它的值在 [0.0, 1.0) 范围内。
参数：无。
返回值：一个 double 类型的数值，表示伪随机数。

public class MathRandomExample {
    public static void main(String[] args) {
        // 生成一个随机整数（0到100之间，包括0但不包括100）
        int randomInt = (int) (Math.random() * 100);
        System.out.println("随机整数（0-100）： " + randomInt);

        // 生成一个随机浮点数（0.0到1.0之间）
        double randomDouble = Math.random();
        System.out.println("随机浮点数（0.0-1.0）： " + randomDouble);

        // 生成一个随机布尔值
        boolean randomBoolean = Math.random() < 0.5;
        System.out.println("随机布尔值： " + randomBoolean);
    }
}

以上是 Math 类中一些常用方法的简要介绍和示例。这些方法在Java编程中广泛应用于各种数学计算和算法中。

System 类

System 类是 Java 标准库中的一个 final 类，它提供了一些基本的系统环境信息，并且包含了一些与环境相关的实用方法。以下是一些 System 类中常用的方法的详细信息：

exit(int status)

作用：终止当前正在运行的Java虚拟机。
参数：一个 int 类型的数值，表示退出状态码。
返回值：无。
示例：

System.exit(0); // 正常终止程序
System.exit(1); // 非正常终止程序

printStackTrace()

作用：打印当前线程的堆栈跟踪到标准错误输出流。
参数：无。
返回值：无。
示例：

new Exception().printStackTrace(); // 打印异常的堆栈跟踪信息

currentTimeMillis()

作用：返回自1970年1月1日00:00:00 UTC以来的毫秒数。
参数：无。
返回值：一个 long 类型的数值，表示自1970年1月1日以来的毫秒数。
示例：

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

nanoTime()

作用：返回自1970年1月1日00:00:00 UTC以来的纳秒数。
参数：无。
返回值：一个 long 类型的数值，表示自1970年1月1日以来的纳秒数。
示例：

long nanoTime = System.nanoTime();
System.out.println("当前时间（纳秒）： " + nanoTime);

arrayCopy(Object src, int srcPos, Object dest, int destPos, int length)

作用：从一个数组中复制指定数量的元素到另一个数组中。
参数：四个 int 类型的参数，分别表示源数组、源数组的起始位置、目标数组、目标数组的起始位置以及要复制的元素数量。
返回值：无。
示例：

int[] srcArray = {1, 2, 3, 4, 5};
int[] destArray = new int[10];
System.arraycopy(srcArray, 0, destArray, 3, 3);
// 结果是 destArray = {0, 0, 0, 1, 2, 3, 4, 5, 0, 0}

setOut(PrintStream out)

作用：设置标准输出流。
参数：一个 PrintStream 类型的对象。
返回值：无。
示例：

PrintStream out = new PrintStream(System.out);
out.println("Hello, World!"); // 输出到标准输出

setErr(PrintStream err)

作用：设置标准错误输出流。
参数：一个 PrintStream 类型的对象。
返回值：无。
示例：

PrintStream err = new PrintStream(System.err);
err.println("Error message!"); // 输出错误信息到标准错误输出

setIn(InputStream in)

作用：设置标准输入流。
参数：一个 InputStream 类型的对象。
返回值：无。
示例：

InputStream in = new ByteArrayInputStream("Hello".getBytes());
System.setIn(in); // 设置标准输入为指定的输入流

System 类的方法提供了与Java程序执行环境交互的途径，包括处理错误输出、控制程序退出、进行基本的内存操作等。这些方法在Java应用程序中非常常见，尤其是在处理系统资源和异常时。

【常见的常用类】（详解方法）

文章目录

常见的常用类

Object 类（所有类的父类）

1. 构造方法

2. 常用方法

3. 覆盖规则

4. 类的继承

5. 用途

String 类

构造方法

常用方法

字符串连接

总结

StringBuilder 类

构造方法

常用方法

Integer 类

BigDecimal 类

Date 类

Math 类

System 类