2026-08-27 · Object、String、包装类——Java 里用得最多的几个类。

Java 常用类

1. Object 类

所有类的父类，任何类都继承了 Object 的方法：

public class Student {
    String name;

    // toString：打印对象时调用
    @Override
    public String toString() {
        return "Student{name='" + name + "'}";
    }
}

Student s = new Student();
s.name = "张三";
System.out.println(s); // Student{name='张三'}（自动调用 toString）

不重写 toString 的默认输出：Student@1b6d3586（类名@哈希值，没意义）。

Object 常用方法：

// equals：比较两个对象是否相等（默认比较地址，需要重写）
@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
    Student other = (Student) obj;
    return name.equals(other.name);
}

// hashCode：和 equals 配套重写（HashMap 会用到）
@Override
public int hashCode() {
    return name.hashCode();
}

// getClass：获取运行时类类型
Class<?> clazz = s.getClass();
System.out.println(clazz.getName()); // Student

重写 equals 规则：

• 自反性：a.equals(a) 必须为 true
• 对称性：a.equals(b) 和 b.equals(a) 结果相同
• 传递性：a.equals(b) 且 b.equals(c)，则 a.equals(c)
• 一致性：多次调用结果相同
• 非 null：a.equals(null) 必须为 false

IDEA 可以自动生成 equals/hashCode：右键 → Generate → equals() and hashCode()。

2. String

字符串，不可变（创建后不能修改）：

String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");

System.out.println(s1 == s2);      // true（共享常量池）
System.out.println(s1 == s3);      // false（new 创建了新对象）
System.out.println(s1.equals(s3)); // true（内容相同）

字符串比较永远用 equals()，不要用 ==（== 比较的是地址，不是内容）。

常用方法

String s = "Hello, World!";

s.length();              // 13（长度）
s.charAt(0);             // 'H'（第几个字符，从 0 开始）
s.substring(7);          // "World!"（从第 7 位截取到末尾）
s.substring(0, 5);       // "Hello"（左闭右开）
s.indexOf("World");      // 7（查找子串位置，找不到返回 -1）
s.contains("World");     // true（是否包含）
s.toUpperCase();         // "HELLO, WORLD!"（转大写）
s.toLowerCase();         // "hello, world!"（转小写）
s.trim();                // 去掉首尾空格
s.replace("World", "Java"); // "Hello, Java!"（替换）
s.startsWith("Hello");   // true（是否以...开头）
s.endsWith("!");         // true（是否以...结尾）
s.isEmpty();             // false（是否为空串）

字符串拼接

// 推荐：+ 拼接（编译器自动优化）
String name = "张三";
String greeting = "Hello, " + name + "!";

// 不推荐：String 拼接（每次 + 都创建新对象，性能差）
// 大量拼接用 StringBuilder
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(", ");
sb.append("World!");
String result = sb.toString(); // "Hello, World!"

少量拼接用 +，大量拼接（循环里）用 StringBuilder。

StringBuilder 详解

StringBuilder sb = new StringBuilder();  // 空构造
sb.append("Hello");      // 追加
sb.append(" ");
sb.append("World");
sb.insert(5, ",");       // 在索引 5 处插入
sb.replace(0, 5, "Hi");  // 替换
sb.delete(2, 4);         // 删除
sb.reverse();            // 反转
sb.length();             // 长度
sb.toString();           // 转成 String

// 链式调用（推荐写法）
String result = new StringBuilder()
    .append("Hello")
    .append(" ")
    .append("World")
    .toString(); // "Hello World"

StringBuilder vs StringBuffer：

区别	StringBuilder	StringBuffer
线程安全	❌ 不安全	✅ 安全（synchronized）
性能	更快	稍慢
使用场景	单线程拼接	多线程拼接

日常用 StringBuilder 即可（99% 的场景是单线程）。StringBuffer 几乎不用。

3. 包装类

基本类型对应的对象类型——泛型和集合只能用包装类：

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

自动装箱与拆箱

// 装箱：基本类型 → 包装类
Integer a = 100;          // 自动装箱（编译器自动调用 Integer.valueOf()）
Integer b = Integer.valueOf(100); // 手动装箱

// 拆箱：包装类 → 基本类型
int c = a;                // 自动拆箱（编译器自动调用 a.intValue()）
int d = a.intValue();     // 手动拆箱

自动装箱/拆箱是 Java 5 引入的语法糖，不用手动调用 valueOf/intValue。

常用方法

// 字符串转数字
int i = Integer.parseInt("100");
double d = Double.parseDouble("3.14");

// 数字转字符串
String s = String.valueOf(100);
String s2 = 100 + "";  // 不推荐

// 常量
Integer.MAX_VALUE;  // 2147483647
Integer.MIN_VALUE;  // -2147483648

包装类比较的坑

Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true（缓存 -128~127）

Integer c = 128;
Integer d = 128;
System.out.println(c == d); // false（超出缓存范围，创建了新对象）
System.out.println(c.equals(d)); // true（内容相同）

包装类比较永远用 equals()，和 String 一样。

4. BigInteger 与 BigDecimal

超大整数和精确小数——int/long 装不下或 double 精度不够时用。

BigInteger（大整数）

// int 最大 21亿，long 最大 922亿亿，BigInteger 没有上限
BigInteger a = new BigInteger("123456789012345678901234567890");
BigInteger b = new BigInteger("999999999999999999999999999999");

BigInteger sum = a.add(b);      // 加法
BigInteger sub = a.subtract(b); // 减法
BigInteger mul = a.multiply(b); // 乘法
BigInteger div = a.divide(b);   // 除法（整除）

System.out.println(sum); // 大数运算结果

BigInteger 是不可变对象，运算返回新对象，原对象不变。

BigDecimal（精确小数）

// double 精度问题
double d = 0.1 + 0.2;
System.out.println(d); // 0.30000000000000004（不是 0.3！）

// BigDecimal 精确计算
BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
BigDecimal sum = a.add(b);
System.out.println(sum); // 0.3（精确）

金融场景必须用 BigDecimal：

BigDecimal price = new BigDecimal("19.99");
BigDecimal quantity = new BigDecimal("3");
BigDecimal total = price.multiply(quantity); // 59.97（精确）

// ❌ 千万不要用 double 构造
BigDecimal bad = new BigDecimal(0.1); // 0.1000000000000000055511151231257827021181583404541015625
BigDecimal good = new BigDecimal("0.1"); // 0.1（精确）

BigDecimal 创建时用字符串构造 new BigDecimal("0.1")，不要用 new BigDecimal(0.1)。这是最常见的坑。