【Java】Java 常用核心类篇 —— 基本类型包装类
目录
- 基本类型包装类
-
- 概念和作用
- 主要特点和功能
- 使用场景
- Byte 类
-
- 常量
- 构造方法
- 常用方法
-
- 类型转换方法
- 字符串相关方法
- 比较方法
- Short 类
-
- 常量
- 构造方法
- 常用方法
-
- 类型转换方法
- 字符串相关方法
- 比较方法
- Integer 类
-
- 常量
- 构造方法
- 常用方法
-
- 类型转换方法
- 字符串相关方法
- 位操作方法
- 比较方法
- Long 类
-
- 常量
- 构造方法
- 常用方法
-
- 类型转换方法
- 字符串相关方法
- 位操作方法
- 比较方法
- Double 类
-
- 常量
- 构造方法
- 常用方法
-
- 类型转换方法
- 字符串相关方法
- 比较方法
- Float 类
-
- 常量
- 构造方法
- 常用方法
-
- 类型转换方法
- 字符串相关方法
- 比较方法
- Boolean 类
-
- 常量
- 构造方法
- 常用方法
-
- 类型转换方法
- 字符串相关方法
- 比较方法
- Character 类
-
- 常量
- 构造方法
- 常用方法
-
- 类型转换方法
- 字符判断方法
- 字符转换方法
- 字符类型获取方法
- 字符编码相关方法
- 字符串相关方法
- 比较方法
- 字符属性判断方法
- 包装类代码示例
- 注意事项
- BigInteger 类和 BigDecimal 类
-
- BigInteger 类
-
- 概述
- 常用构造方法
- 常用方法
- 代码示例
- BigDecimal 类
-
- 概述
- 常用构造方法
- 常用方法
- 代码示例
基本类型包装类
基本类型包装类是 Java 中的一种机制，用于将基本数据类型封装成对象，以方便在一些需要对象的场景中使用基本数据类型。
概念和作用
基本数据类型包括 byte、short、int、long、float、double、char、boolean，它们不是对象，在实际编程中有时需要将基本数据类型当作对象来处理，比如在集合框架中，只能存储对象，这时就需要基本类型包装类。基本类型包装类为基本数据类型提供了对象的表示形式，每个基本数据类型都有对应的包装类：Byte、Short、Integer、Long、Float、Double、Character、Boolean。
主要特点和功能
- 提供方法和属性：以 Integer 类为例，它提供了许多实用的方法，如 parseInt() 方法可以将字符串解析为整数，compareTo() 方法用于比较两个整数的大小等。还包含一些常量，如 Integer.MAX_VALUE 表示 int 类型的最大值。
- 自动装箱和拆箱：Java 5 开始引入了自动装箱和拆箱机制。自动装箱是指将基本数据类型自动转换为对应的包装类对象，自动拆箱则是将包装类对象自动转换为基本数据类型。例如：
Integer num1 = 10; // 自动装箱
int num2 = num1; // 自动拆箱
- 缓存机制：部分包装类实现了缓存机制，以提高性能和节省内存。例如 Integer 类默认会缓存 - 128 到 127 之间的整数，当创建在这个范围内的 Integer 对象时，会直接返回缓存中的对象，而不是创建新的对象。
使用场景
- 作为方法参数和返回值：当方法需要接收或返回对象类型的数据，但实际处理的是基本数据类型时，就可以使用包装类。比如，在 Java 的多线程编程中，Callable 接口的 call() 方法需要返回一个 Object 类型的值，如果你想返回一个整数，就可以返回 Integer 类型。
- 集合类操作：在使用集合类如 ArrayList、HashMap 等时，只能存储对象，所以需要将基本数据类型包装成对象后才能放入集合中。例如：
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1); // 自动装箱，将int类型的1包装成Integer对象
list.add(2);
for (Integer num : list) {
System.out.println(num);
}
}
}
Byte 类
Byte 类是 byte 基本数据类型的包装类，位于 java.lang 包下。
常量
Byte.MIN_VALUE：byte 类型的最小值，即 -128。
Byte.MAX_VALUE：byte 类型的最大值，即 127。
Byte.SIZE：byte 类型的位数，为 8 位。
Byte.BYTES：byte 类型占用的字节数，为 1 字节。
构造方法
Byte(byte value)：使用 byte 值创建 Byte 对象。
Byte(String s)：将字符串解析为 byte 并创建 Byte 对象，该方法从 Java 9 开始已被弃用。
常用方法
类型转换方法
byte byteValue()：返回此 Byte 对象的 byte 值。
short shortValue()：将 Byte 对象转换为 short 类型。
int intValue()：将 Byte 对象转换为 int 类型。
long longValue()：将 Byte 对象转换为 long 类型。
float floatValue()：将 Byte 对象转换为 float 类型。
double doubleValue()：将 Byte 对象转换为 double 类型。
字符串相关方法
static Byte decode(String nm)：将字符串解码为 Byte。
static byte parseByte(String s)：将字符串解析为 byte 类型。
static byte parseByte(String s, int radix)：将指定基数的字符串解析为 byte 类型。
static String toString(byte b)：返回表示指定 byte 的字符串。
static Byte valueOf(byte b)：返回表示指定 byte 值的 Byte 实例。
static Byte valueOf(String s)：将字符串解析为 Byte 对象。
static Byte valueOf(String s, int radix)：将指定基数的字符串解析为 Byte 对象。
比较方法
int compareTo(Byte anotherByte)：比较两个 Byte 对象的数值大小。
boolean equals(Object obj)：判断两个 Byte 对象是否相等。
static int compare(byte x, byte y)：比较两个 byte 值的大小。
static int hashCode(byte value)：返回 byte 值的哈希码。
static byte reverseBytes(byte b)：反转 byte 值的字节顺序。
Short 类
Short 类是 short 基本数据类型的包装类，位于 java.lang 包下。
常量
Short.MIN_VALUE：short 类型的最小值，即 -32768。
Short.MAX_VALUE：short 类型的最大值，即 32767。
Short.SIZE：short 类型的位数，为 16 位。
Short.BYTES：short 类型占用的字节数，为 2 字节。
构造方法
Short(short value)：使用 short 值创建 Short 对象。
Short(String s)：将字符串解析为 short 并创建 Short 对象，该方法从 Java 9 开始已被弃用。
常用方法
类型转换方法
short shortValue()：返回此 Short 对象的 short 值。
int intValue()：将 Short 对象转换为 int 类型。
long longValue()：将 Short 对象转换为 long 类型。
float floatValue()：将 Short 对象转换为 float 类型。
double doubleValue()：将 Short 对象转换为 double 类型。
字符串相关方法
static Short decode(String nm)：将字符串解码为 Short。
static short parseShort(String s)：将字符串解析为 short 类型。
static short parseShort(String s, int radix)：将指定基数的字符串解析为 short 类型。
static String toString(short s)：返回表示指定 short 的字符串。
static Short valueOf(short s)：返回表示指定 short 值的 Short 实例。
static Short valueOf(String s)：将字符串解析为 Short 对象。
static Short valueOf(String s, int radix)：将指定基数的字符串解析为 Short 对象。
比较方法
int compareTo(Short anotherShort)：比较两个 Short 对象的数值大小。boolean equals(Object obj)：判断两个 Short 对象是否相等。static int compare(short x, short y)：比较两个 short 值的大小。static int hashCode(short value)：返回 short 值的哈希码。static short reverseBytes(short s)：反转 short 值的字节顺序。
Integer 类
Integer 类是 int 基本数据类型的包装类，位于 java.lang 包下。
常量
Integer.MIN_VALUE：int 类型的最小值，即 -2147483648。Integer.MAX_VALUE：int 类型的最大值，即 2147483647。Integer.SIZE：int 类型的位数，为 32 位。Integer.BYTES：int 类型占用的字节数，为 4 字节。
构造方法
Integer(int value)：使用 int 值创建 Integer 对象。Integer(String s)：将字符串解析为 int 并创建 Integer 对象，该方法从 Java 9 开始已被弃用。
常用方法
类型转换方法
int intValue()：返回此 Integer 对象的 int 值。long longValue()：将 Integer 对象转换为 long 类型。float floatValue()：将 Integer 对象转换为 float 类型。double doubleValue()：将 Integer 对象转换为 double 类型。
字符串相关方法
static Integer decode(String nm)：将字符串解码为 Integer。static int parseInt(String s)：将字符串解析为 int 类型。static int parseInt(String s, int radix)：将指定基数的字符串解析为 int 类型。static String toBinaryString(int i)：将 int 转换为二进制字符串。static String toHexString(int i)：将 int 转换为十六进制字符串。static String toOctalString(int i)：将 int 转换为八进制字符串。static String toString(int i)：返回表示指定 int 的字符串。static String toString(int i, int radix)：返回指定基数下表示 int 的字符串。static Integer valueOf(int i)：返回表示指定 int 值的 Integer 实例。static Integer valueOf(String s)：将字符串解析为 Integer 对象。static Integer valueOf(String s, int radix)：将指定基数的字符串解析为 Integer 对象。
位操作方法
static int bitCount(int i)：返回 int 值的二进制补码表示中 1 的位数。static int highestOneBit(int i)：返回 int 值的最高位 1 所在位置对应的整数值。static int lowestOneBit(int i)：返回 int 值的最低位 1 所在位置对应的整数值。static int numberOfLeadingZeros(int i)：返回 int 值的二进制补码表示中最高位 1 之前的 0 的位数。static int numberOfTrailingZeros(int i)：返回 int 值的二进制补码表示中最低位 1 之后的 0 的位数。static int reverse(int i)：反转 int 值的二进制补码表示中的位顺序。static int reverseBytes(int i)：反转 int 值的字节顺序。static int rotateLeft(int i, int distance)：将 int 值的二进制补码表示向左循环移位。static int rotateRight(int i, int distance)：将 int 值的二进制补码表示向右循环移位。
比较方法
int compareTo(Integer anotherInteger)：比较两个 Integer 对象的数值大小。boolean equals(Object obj)：判断两个 Integer 对象是否相等。static int compare(int x, int y)：比较两个 int 值的大小。static int compareUnsigned(int x, int y)：比较两个无符号 int 值的大小。static int divideUnsigned(int dividend, int divisor)：对两个无符号 int 值进行除法运算。static int hashCode(int value)：返回 int 值的哈希码。static int remainderUnsigned(int dividend, int divisor)：对两个无符号 int 值进行取余运算。
Long 类
Long 类是 long 基本数据类型的包装类，位于 java.lang 包下。
常量
Long.MIN_VALUE：long 类型的最小值，即 -9223372036854775808L。Long.MAX_VALUE：long 类型的最大值，即 9223372036854775807L。Long.SIZE：long 类型的位数，为 64 位。Long.BYTES：long 类型占用的字节数，为 8 字节。
构造方法
Long(long value)：使用 long 值创建 Long 对象。Long(String s)：将字符串解析为 long 并创建 Long 对象，该方法从 Java 9 开始已被弃用。
常用方法
类型转换方法
long longValue()：返回此 Long 对象的 long 值。int intValue()：将 Long 对象转换为 int 类型（可能会丢失精度）。float floatValue()：将 Long 对象转换为 float 类型。double doubleValue()：将 Long 对象转换为 double 类型。
字符串相关方法
static Long decode(String nm)：将字符串解码为 Long。static long parseLong(String s)：将字符串解析为 long 类型。static long parseLong(String s, int radix)：将指定基数的字符串解析为 long 类型。static String toBinaryString(long i)：将 long 转换为二进制字符串。static String toHexString(long i)：将 long 转换为十六进制字符串。static String toOctalString(long i)：将 long 转换为八进制字符串。static String toString(long i)：返回表示指定 long 的字符串。static String toString(long i, int radix)：返回指定基数下表示 long 的字符串。static Long valueOf(long l)：返回表示指定 long 值的 Long 实例。static Long valueOf(String s)：将字符串解析为 Long 对象。static Long valueOf(String s, int radix)：将指定基数的字符串解析为 Long 对象。
位操作方法
static int bitCount(long i)：返回 long 值的二进制补码表示中 1 的位数。static long highestOneBit(long i)：返回 long 值的最高位 1 所在位置对应的长整数值。static long lowestOneBit(long i)：返回 long 值的最低位 1 所在位置对应的长整数值。static int numberOfLeadingZeros(long i)：返回 long 值的二进制补码表示中最高位 1 之前的 0 的位数。static int numberOfTrailingZeros(long i)：返回 long 值的二进制补码表示中最低位 1 之后的 0 的位数。static long reverse(long i)：反转 long 值的二进制补码表示中的位顺序。static long reverseBytes(long i)：反转 long 值的字节顺序。static long rotateLeft(long i, int distance)：将 long 值的二进制补码表示向左循环移位。static long rotateRight(long i, int distance)：将 long 值的二进制补码表示向右循环移位。
比较方法
int compareTo(Long anotherLong)：比较两个 Long 对象的数值大小。boolean equals(Object obj)：判断两个 Long 对象是否相等。static int compare(long x, long y)：比较两个 long 值的大小。static int compareUnsigned(long x, long y)：比较两个无符号 long 值的大小。static long divideUnsigned(long dividend, long divisor)：对两个无符号 long 值进行除法运算。static int hashCode(long value)：返回 long 值的哈希码。static long remainderUnsigned(long dividend, long divisor)：对两个无符号 long 值进行取余运算。
Double 类
Double 类是 double 基本数据类型的包装类，位于 java.lang 包下。
常量
Double.MIN_VALUE：double 类型的最小正非零值，即 4.9e - 324。Double.MAX_VALUE：double 类型的最大正有限值，即 1.7976931348623157e+308。Double.NaN：表示非数字值。Double.POSITIVE_INFINITY：表示正无穷大。Double.NEGATIVE_INFINITY：表示负无穷大。Double.SIZE：double 类型的位数，为 64 位。Double.BYTES：double 类型占用的字节数，为 8 字节。
构造方法
Double(double value)：使用 double 值创建 Double 对象。Double(String s)：将字符串解析为 double 并创建 Double 对象，该方法从 Java 9 开始已被弃用。
常用方法
类型转换方法
double doubleValue()：返回此 Double 对象的 double 值。int intValue()：将 Double 对象转换为 int 类型（可能会丢失精度）。long longValue()：将 Double 对象转换为 long 类型（可能会丢失精度）。float floatValue()：将 Double 对象转换为 float 类型（可能会丢失精度）。
字符串相关方法
static double parseDouble(String s)：将字符串解析为 double 类型。static String toString(double d)：返回表示指定 double 的字符串。static Double valueOf(double d)：返回表示指定 double 值的 Double 实例。static Double valueOf(String s)：将字符串解析为 Double 对象。
比较方法
int compareTo(Double anotherDouble)：比较两个 Double 对象的数值大小。boolean equals(Object obj)：判断两个 Double 对象是否相等。static int compare(double d1, double d2)：比较两个 double 值的大小。static boolean isNaN(double v)：判断 double 值是否为非数字。static boolean isInfinite(double v)：判断 double 值是否为无穷大。static long doubleToLongBits(double value)：将 double 值转换为 long 类型的位表示。static long doubleToRawLongBits(double value)：将 double 值转换为 long 类型的位表示，不处理 NaN 情况。static double longBitsToDouble(long bits)：将 long 类型的位表示转换为 double 值。
Float 类
Float 类是 float 基本数据类型的包装类，位于 java.lang 包下。
常量
Float.MIN_VALUE：float 类型的最小正非零值，即 1.4E - 45f。Float.MAX_VALUE：float 类型的最大正有限值，即 3.4028235E+38f。Float.NaN：表示非数字值。Float.POSITIVE_INFINITY：表示正无穷大。Float.NEGATIVE_INFINITY：表示负无穷大。Float.SIZE：float 类型的位数，为 32 位。Float.BYTES：float 类型占用的字节数，为 4 字节。
构造方法
Float(float value)：使用 float 值创建 Float 对象。Float(double value)：使用 double 值创建 Float 对象，会进行类型转换。Float(String s)：将字符串解析为 float 并创建 Float 对象，该方法从 Java 9 开始已被弃用。
常用方法
类型转换方法
float floatValue()：返回此 Float 对象的 float 值。int intValue()：将 Float 对象转换为 int 类型（可能会丢失精度）。long longValue()：将 Float 对象转换为 long 类型（可能会丢失精度）。double doubleValue()：将 Float 对象转换为 double 类型。
字符串相关方法
static float parseFloat(String s)：将字符串解析为 float 类型。static String toString(float f)：返回表示指定 float 的字符串。static Float valueOf(float f)：返回表示指定 float 值的 Float 实例。static Float valueOf(String s)：将字符串解析为 Float 对象。
比较方法
int compareTo(Float anotherFloat)：比较两个 Float 对象的数值大小。boolean equals(Object obj)：判断两个 Float 对象是否相等。static int compare(float f1, float f2)：比较两个 float 值的大小。static boolean isNaN(float v)：判断 float 值是否为非数字。static boolean isInfinite(float v)：判断 float 值是否为无穷大。static int floatToIntBits(float value)：将 float 值转换为 int 类型的位表示。static int floatToRawIntBits(float value)：将 float 值转换为 int 类型的位表示，不处理 NaN 情况。static float intBitsToFloat(int bits)：将 int 类型的位表示转换为 float 值。
Boolean 类
Boolean 类是 boolean 基本数据类型的包装类，位于 java.lang 包下。
常量
Boolean.TRUE：表示 true 的 Boolean 对象。Boolean.FALSE：表示 false 的 Boolean 对象。
构造方法
Boolean(boolean value)：使用 boolean 值创建 Boolean 对象。Boolean(String s)：如果字符串为 “true”（忽略大小写），则创建表示 true 的 Boolean 对象，否则创建表示 false 的对象，该方法从 Java 9 开始已被弃用。
常用方法
类型转换方法
boolean booleanValue()：返回此 Boolean 对象的 boolean 值。
字符串相关方法
static boolean parseBoolean(String s)：将字符串解析为 boolean 类型，只有当字符串为 “true”（忽略大小写）时返回 true，否则返回 false。static String toString(boolean b)：返回表示指定 boolean 的字符串。static Boolean valueOf(boolean b)：返回表示指定 boolean 值的 Boolean 实例。static Boolean valueOf(String s)：将字符串解析为 Boolean 对象。
比较方法
int compareTo(Boolean b)：比较两个 Boolean 对象，true 大于 false。boolean equals(Object obj)：判断两个 Boolean 对象是否相等。static boolean logicalAnd(boolean a, boolean b)：对两个 boolean 值进行逻辑与运算。static boolean logicalOr(boolean a, boolean b)：对两个 boolean 值进行逻辑或运算。static boolean logicalXor(boolean a, boolean b)：对两个 boolean 值进行逻辑异或运算。
Character 类
Character 类是 char 基本数据类型的包装类，位于 java.lang 包下。
常量
Character.MIN_VALUE：char 类型的最小值，即 ‘\u0000’。Character.MAX_VALUE：char 类型的最大值，即 ‘\uffff’。Character.SIZE：char 类型的位数，为 16 位。Character.BYTES：char 类型占用的字节数，为 2 字节。
构造方法
Character(char value)：使用 char 值创建 Character 对象。
常用方法
类型转换方法
char charValue()：返回此 Character 对象的 char 值。
字符判断方法
static boolean isLetter(char ch)：判断字符是否为字母。static boolean isDigit(char ch)：判断字符是否为数字。static boolean isWhitespace(char ch)：判断字符是否为空白字符。static boolean isUpperCase(char ch)：判断字符是否为大写字母。static boolean isLowerCase(char ch)：判断字符是否为小写字母。static boolean isTitleCase(char ch)：判断字符是否为标题大小写字母。static boolean isLetterOrDigit(char ch)：判断字符是否为字母或数字。static boolean isDefined(char ch)：判断字符是否在 Unicode 字符集中有定义。static boolean isISOControl(char ch)：判断字符是否为 ISO 控制字符。static boolean isMirrored(char ch)：判断字符在 Unicode 中是否有镜像映射。
字符转换方法
static char toUpperCase(char ch)：将字符转换为大写。static char toLowerCase(char ch)：将字符转换为小写。static char toTitleCase(char ch)：将字符转换为标题大小写。
字符类型获取方法
static int getType(char ch)：返回字符的 Unicode 通用类别。
字符编码相关方法
static int codePointAt(char[] a, int index)：返回指定索引处字符的 Unicode 代码点。static int codePointBefore(char[] a, int index)：返回指定索引前一个字符的 Unicode 代码点。static int codePointCount(char[] a, int beginIndex, int endIndex)：返回指定字符数组范围内的代码点数量。static int offsetByCodePoints(char[] a, int startIndex, int codePointOffset)：返回从起始索引偏移指定代码点数后的索引。
字符串相关方法
static String toString(char c)：返回表示指定 char 的字符串。static Character valueOf(char c)：返回表示指定 char 值的 Character 实例。
比较方法
int compareTo(Character anotherCharacter)：比较两个 Character 对象的字符值。boolean equals(Object obj)：判断两个 Character 对象是否相等。
字符属性判断方法
static boolean isJavaIdentifierStart(char ch)：判断指定字符是否可以作为 Java 标识符的起始字符。在 Java 中，标识符可以是变量名、方法名、类名等，起始字符可以是字母（包括 Unicode 字母）、美元符号 $ 或下划线 _。static boolean isJavaIdentifierPart(char ch)：判断指定字符是否可以作为 Java 标识符的一部分。除了可以作为起始字符的字符外，数字也可以作为标识符的一部分。static boolean isIdentifierIgnorable(char ch)：判断指定字符是否可以在 Java 标识符中被忽略。这些字符通常是一些 Unicode 控制字符，在标识符中没有实际语义。
包装类代码示例
public class WrapperClassMethodsExample {
public static void main(String[] args) {
// Byte 类示例
byte byteValue = 10;
Byte byteObj = Byte.valueOf(byteValue);
System.out.println("Byte 类示例：");
System.out.println("Byte 对象的值: " + byteObj);
System.out.println("Byte 转 int: " + byteObj.intValue());
try {
System.out.println("字符串转 Byte: " + Byte.parseByte("20"));
} catch (NumberFormatException e) {
System.out.println("字符串格式错误: " + e.getMessage());
}
// Short 类示例
short shortValue = 100;
Short shortObj = Short.valueOf(shortValue);
System.out.println("\nShort 类示例：");
System.out.println("Short 对象的值: " + shortObj);
System.out.println("Short 转 long: " + shortObj.longValue());
try {
System.out.println("字符串转 Short: " + Short.parseShort("200"));
} catch (NumberFormatException e) {
System.out.println("字符串格式错误: " + e.getMessage());
}
// Integer 类示例
int intValue = 1000;
Integer integerObj = Integer.valueOf(intValue);
System.out.println("\nInteger 类示例：");
System.out.println("Integer 对象的值: " + integerObj);
System.out.println("Integer 转 double: " + integerObj.doubleValue());
System.out.println("整数转二进制字符串: " + Integer.toBinaryString(intValue));
try {
System.out.println("字符串转 Integer: " + Integer.parseInt("2000"));
} catch (NumberFormatException e) {
System.out.println("字符串格式错误: " + e.getMessage());
}
// Long 类示例
long longValue = 10000L;
Long longObj = Long.valueOf(longValue);
System.out.println("\nLong 类示例：");
System.out.println("Long 对象的值: " + longObj);
System.out.println("Long 转 float: " + longObj.floatValue());
System.out.println("长整数转十六进制字符串: " + Long.toHexString(longValue));
try {
System.out.println("字符串转 Long: " + Long.parseLong("20000"));
} catch (NumberFormatException e) {
System.out.println("字符串格式错误: " + e.getMessage());
}
// Double 类示例
double doubleValue = 3.14;
Double doubleObj = Double.valueOf(doubleValue);
System.out.println("\nDouble 类示例：");
System.out.println("Double 对象的值: " + doubleObj);
System.out.println("Double 转 int（可能丢失精度）: " + doubleObj.intValue());
try {
System.out.println("字符串转 Double: " + Double.parseDouble("2.71"));
} catch (NumberFormatException e) {
System.out.println("字符串格式错误: " + e.getMessage());
}
// Float 类示例
float floatValue = 1.23f;
Float floatObj = Float.valueOf(floatValue);
System.out.println("\nFloat 类示例：");
System.out.println("Float 对象的值: " + floatObj);
System.out.println("Float 转 long（可能丢失精度）: " + floatObj.longValue());
try {
System.out.println("字符串转 Float: " + Float.parseFloat("2.34"));
} catch (NumberFormatException e) {
System.out.println("字符串格式错误: " + e.getMessage());
}
// Boolean 类示例
boolean booleanValue = true;
Boolean booleanObj = Boolean.valueOf(booleanValue);
System.out.println("\nBoolean 类示例：");
System.out.println("Boolean 对象的值: " + booleanObj);
System.out.println("字符串转 Boolean: " + Boolean.parseBoolean("true"));
System.out.println("逻辑与运算: " + Boolean.logicalAnd(true, false));
// Character 类示例
char charValue = 'A';
Character charObj = Character.valueOf(charValue);
System.out.println("\nCharacter 类示例：");
System.out.println("Character 对象的值: " + charObj);
System.out.println("判断是否为字母: " + Character.isLetter(charValue));
System.out.println("转换为小写: " + Character.toLowerCase(charValue));
}
}
注意事项
- 空指针风险
- 包装类可以为 null，拆箱时可能抛出 NullPointerException：
Integer i = null;
int j = i; // 运行时异常：NullPointerException
-
性能开销
- 频繁装箱/拆箱会影响性能（如循环中大量操作包装类）。
-
比较操作
- 使用 == 比较对象时，比较的是引用地址，而非值（缓存范围外会失败）。
- 推荐使用 equals() 或先拆箱再比较：
Integer a = 200;
Integer b = 200;
System.out.println(a.intValue() == b.intValue()); // true（值比较）
BigInteger 类和 BigDecimal 类
在 Java 中，BigInteger 类和 BigDecimal 类分别用于处理大整数和大十进制数，它们位于 java.math 包下。这两个类可以处理超出基本数据类型范围的数值，为高精度计算提供了支持。以下是对这两个类的详细介绍：
BigInteger 类
概述
BigInteger 类用于表示任意大小的整数，不受 int、long 等基本数据类型取值范围的限制。
常用构造方法
BigInteger(String val)：将十进制字符串表示的整数转换为 BigInteger 对象。BigInteger(String val, int radix)：将指定基数（进制）的字符串表示的整数转换为 BigInteger 对象。BigInteger(byte[] val)：将字节数组表示的整数转换为 BigInteger 对象。
常用方法
- 基本运算方法
BigInteger add(BigInteger val)：返回两个 BigInteger 对象相加的结果。BigInteger subtract(BigInteger val)：返回两个 BigInteger 对象相减的结果。BigInteger multiply(BigInteger val)：返回两个 BigInteger 对象相乘的结果。BigInteger divide(BigInteger val)：返回两个 BigInteger 对象相除的结果（整数除法）。BigInteger[] divideAndRemainder(BigInteger val)：返回两个 BigInteger 对象相除的商和余数，结果存储在长度为 2 的数组中，第一个元素是商，第二个元素是余数。
- 比较方法
int compareTo(BigInteger val)：比较两个 BigInteger 对象的大小。如果当前对象小于 val，返回 -1；如果相等，返回 0；如果大于 val，返回 1。boolean equals(Object x)：判断两个 BigInteger 对象是否相等。
- 其他方法
BigInteger abs()：返回 BigInteger 对象的绝对值。BigInteger pow(int exponent)：返回当前 BigInteger 对象的指定次幂。
代码示例
import java.math.BigInteger;
public class BigIntegerExample {
public static void main(String[] args) {
BigInteger num1 = new BigInteger("12345678901234567890");
BigInteger num2 = new BigInteger("98765432109876543210");
// 加法
BigInteger sum = num1.add(num2);
System.out.println("加法结果: " + sum);
// 减法
BigInteger difference = num2.subtract(num1);
System.out.println("减法结果: " + difference);
// 乘法
BigInteger product = num1.multiply(num2);
System.out.println("乘法结果: " + product);
// 除法
BigInteger quotient = num2.divide(num1);
System.out.println("除法结果: " + quotient);
// 比较
int comparison = num1.compareTo(num2);
if (comparison < 0) {
System.out.println("num1 小于 num2");
} else if (comparison == 0) {
System.out.println("num1 等于 num2");
} else {
System.out.println("num1 大于 num2");
}
}
}
BigDecimal 类
概述
BigDecimal 类用于表示任意精度的十进制数，常用于需要高精度计算的场景，如金融领域的货币计算。
常用构造方法
BigDecimal(String val)：将十进制字符串表示的数转换为 BigDecimal 对象，推荐使用该构造方法，因为它能避免使用 double 类型构造时可能出现的精度问题。BigDecimal(double val)：将 double 类型的数转换为 BigDecimal 对象，但由于 double 类型本身存在精度问题，不建议使用。BigDecimal(int val)：将 int 类型的数转换为 BigDecimal 对象。
常用方法
- 基本运算方法
BigDecimal add(BigDecimal augend)：返回两个 BigDecimal 对象相加的结果。BigDecimal subtract(BigDecimal subtrahend)：返回两个 BigDecimal 对象相减的结果。BigDecimal multiply(BigDecimal multiplicand)：返回两个 BigDecimal 对象相乘的结果。BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)：返回两个 BigDecimal 对象相除的结果，需要指定保留的小数位数和舍入模式。
- 比较方法
int compareTo(BigDecimal val)：比较两个 BigDecimal 对象的大小。如果当前对象小于 val，返回 -1；如果相等，返回 0；如果大于 val，返回 1。boolean equals(Object x)：判断两个 BigDecimal 对象是否相等，该方法会比较值和精度。
其他方法BigDecimal setScale(int newScale, RoundingMode roundingMode)：设置 BigDecimal 对象的小数位数，并指定舍入模式。int intValue()：将 BigDecimal 对象转换为 int 类型（可能会丢失精度）。
代码示例
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalExample {
public static void main(String[] args) {
BigDecimal num1 = new BigDecimal("10.25");
BigDecimal num2 = new BigDecimal("2.5");
// 加法
BigDecimal sum = num1.add(num2);
System.out.println("加法结果: " + sum);
// 减法
BigDecimal difference = num1.subtract(num2);
System.out.println("减法结果: " + difference);
// 乘法
BigDecimal product = num1.multiply(num2);
System.out.println("乘法结果: " + product);
// 除法
BigDecimal quotient = num1.divide(num2, 2, RoundingMode.HALF_UP);
System.out.println("除法结果: " + quotient);
// 比较
int comparison = num1.compareTo(num2);
if (comparison < 0) {
System.out.println("num1 小于 num2");
} else if (comparison == 0) {
System.out.println("num1 等于 num2");
} else {
System.out.println("num1 大于 num2");
}
// 设置小数位数
BigDecimal scaledNum = num1.setScale(1, RoundingMode.HALF_UP);
System.out.println("设置小数位数后的结果: " + scaledNum);
}
}