Java API (二)：从 Object 类到正则表达式的核心详解

钮祜禄.爱因斯晨

发布于 2025-07-23 09:29:46

14100

代码可运行

运行总次数：0

代码可运行

个人主页-爱因斯晨

Java API 详解 (一)

互三啦，兄弟们！！加油加油！！

一、Object 类

Object类是 Java 语言中唯一没有父类的类，所有类都直接或间接继承自它，这意味着任何 Java 对象都能调用 Object 类中的方法。

1. 核心方法解析

toString()：返回对象的字符串表示。默认实现为类名@哈希值的十六进制，实际开发中通常会重写该方法，以返回对象的具体信息。例如：

class Person {
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

// 测试代码
public class TestToString {
    public static void main(String[] args) {
        Person p = new Person("张三", 20);
        System.out.println(p); // 直接打印对象会调用toString()，输出：Person{name='张三', age=20}
    }
}

equals()：用于比较两个对象是否相等。默认实现是比较对象的内存地址（即this == obj），但在实际业务中，我们常重写该方法以实现自定义的相等逻辑。重写时需遵循对称性、传递性等原则，且建议同时重写hashCode()方法。

@Override
public boolean equals(Object obj) {
    // 1. 自反性：自身比较返回true
    if (this == obj) return true;
    // 2. 非空判断：传入null返回false
    if (obj == null) return false;
    // 3. 类型判断：类型不同返回false
    if (getClass() != obj.getClass()) return false;
    // 4. 强转并比较属性
    Person other = (Person) obj;
    return age == other.age && Objects.equals(name, other.name);
}

// 重写hashCode()
@Override
public int hashCode() {
    return Objects.hash(name, age);
}

hashCode()：返回对象的哈希码值，主要用于哈希表（如 HashMap）等数据结构。关键原则是：若两个对象通过equals()比较返回 true，则它们的hashCode()必须相等；若hashCode()不相等，则equals()一定返回 false。
getClass()：返回对象的运行时类（Class 对象），可用于反射机制、判断对象具体类型等场景。例如：

public class TestGetClass {
    public static void main(String[] args) {
        Person p = new Person("李四", 25);
        Class<?> clazz = p.getClass();
        System.out.println("类名：" + clazz.getSimpleName()); // 输出：Person
        System.out.println("全限定名：" + clazz.getName()); // 输出：包名.Person
    }
}

finalize()：该方法在垃圾回收器回收对象前调用，但 JDK 9 起已被标记为过时，不建议使用，资源释放可通过 try-with-resources 等机制实现。

二、对象克隆与 Objects 工具类

在实际开发中，有时需要创建一个与原对象内容相同的新对象，这就涉及到克隆机制；而 Objects 工具类则为对象操作提供了更多便捷方法。

1. 克隆机制

克隆分为浅克隆和深克隆两种，它们的核心区别在于对引用类型字段的处理方式。

浅克隆：基本数据类型的字段会被复制，引用类型的字段仅复制引用地址（新对象与原对象共享引用类型数据）。实现步骤为：让类实现Cloneable接口，并重写Object类的clone()方法。示例：

class Student implements Cloneable {
    private String name; // 引用类型
    private int age; // 基本类型
    private Teacher teacher; // 引用类型

    public Student(String name, int age, Teacher teacher) {
        this.name = name;
        this.age = age;
        this.teacher = teacher;
    }

    @Override
    public Student clone() throws CloneNotSupportedException {
        return (Student) super.clone();
    }

    // getter和setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public Teacher getTeacher() { return teacher; }
    public void setTeacher(Teacher teacher) { this.teacher = teacher; }
}

class Teacher {
    private String subject;
    public Teacher(String subject) { this.subject = subject; }
    public String getSubject() { return subject; }
    public void setSubject(String subject) { this.subject = subject; }
}

// 浅克隆测试
public class TestShallowClone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher t = new Teacher("数学");
        Student s1 = new Student("王五", 18, t);
        Student s2 = s1.clone();

        // 基本类型字段独立
        s2.setAge(19);
        System.out.println(s1.getAge()); // 18（不受影响）

        // 引用类型字段共享
        s2.getTeacher().setSubject("语文");
        System.out.println(s1.getTeacher().getSubject()); // 语文（受影响）
    }
}

深克隆：不仅复制基本类型字段，还会递归复制所有引用类型字段（新对象与原对象的引用类型数据完全独立）。实现方式有两种：

class Address implements Cloneable {
    private String city;
    public Address(String city) { this.city = city; }
    
    @Override
    public Address clone() throws CloneNotSupportedException {
        return (Address) super.clone();
    }

    // getter和setter
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
}

class User implements Cloneable {
    private String username;
    private Address address;

    public User(String username, Address address) {
        this.username = username;
        this.address = address;
    }

    @Override
    public User clone() throws CloneNotSupportedException {
        User user = (User) super.clone();
        // 对引用类型字段进行克隆
        user.address = this.address.clone();
        return user;
    }

    // getter和setter
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }
}

// 深克隆测试
public class TestDeepClone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address addr = new Address("北京");
        User u1 = new User("赵六", addr);
        User u2 = u1.clone();

        u2.getAddress().setCity("上海");
        System.out.println(u1.getAddress().getCity()); // 北京（不受影响）
    }
}
import java.io.*;

class Product implements Serializable {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    // 深克隆方法
    public Product deepClone() throws IOException, ClassNotFoundException {
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);

        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Product) ois.readObject();
    }

    // getter和setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}

方式一：嵌套克隆
方式二：序列化实现

2. Objects 工具类

java.util.Objects是 JDK 7 新增的工具类，提供了一系列静态方法用于对象的安全操作，能有效避免空指针异常。常用方法代码示例：

public class TestObjects {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        String c = null;

        // equals方法
        System.out.println(Objects.equals(a, b)); // true
        System.out.println(Objects.equals(a, c)); // false（不会抛空指针）

        // 判空方法
        System.out.println(Objects.isNull(c)); // true
        System.out.println(Objects.nonNull(a)); // true

        // 非空校验
        try {
            Objects.requireNonNull(c, "参数不能为null");
        } catch (NullPointerException e) {
            System.out.println(e.getMessage()); // 参数不能为null
        }

        // 哈希码计算
        int hash = Objects.hashCode(a, 123);
        System.out.println(hash);
    }
}

三、BigInteger

Java 中的基本数据类型long有取值范围限制（-2^63 到 2^63-1），当需要处理超过该范围的整数时，就需要使用BigInteger类。

1. 基本特性

BigInteger位于java.math包下，它可以表示任意大小的整数，不受基本数据类型取值范围的限制。

2. 常用操作代码示例

import java.math.BigInteger;

public class TestBigInteger {
    public static void main(String[] args) {
        // 创建BigInteger对象
        BigInteger bigNum1 = new BigInteger("123456789012345678901234567890");
        BigInteger bigNum2 = new BigInteger("987654321098765432109876543210");

        // 加法
        BigInteger sum = bigNum1.add(bigNum2);
        System.out.println("和：" + sum);

        // 减法
        BigInteger difference = bigNum2.subtract(bigNum1);
        System.out.println("差：" + difference);

        // 乘法
        BigInteger product = bigNum1.multiply(bigNum2);
        System.out.println("积：" + product);

        // 除法（需确保能整除）
        BigInteger quotient = bigNum2.divide(new BigInteger("10"));
        System.out.println("商：" + quotient);

        // 取余
        BigInteger remainder = bigNum1.remainder(new BigInteger("7"));
        System.out.println("余数：" + remainder);

        // 比较大小
        int compareResult = bigNum1.compareTo(bigNum2);
        if (compareResult < 0) {
            System.out.println("bigNum1 < bigNum2");
        } else if (compareResult > 0) {
            System.out.println("bigNum1 > bigNum2");
        } else {
            System.out.println("bigNum1 = bigNum2");
        }
    }
}

四、BigDecimal

float和double类型的浮点数在运算时可能会出现精度丢失问题，而BigDecimal类则提供了高精度的小数运算支持。

1. 精度问题示例

public class TestBigDecimalProblem {
    public static void main(String[] args) {
        System.out.println(0.1 + 0.2); // 输出0.30000000000000004（精度丢失）
    }
}

2. BigDecimal 常用操作代码

import java.math.BigDecimal;
import java.math.RoundingMode;

public class TestBigDecimal {
    public static void main(String[] args) {
        // 推荐使用String构造方法
        BigDecimal num1 = new BigDecimal("0.1");
        BigDecimal num2 = new BigDecimal("0.2");

        // 加法
        BigDecimal sum = num1.add(num2);
        System.out.println("0.1 + 0.2 = " + sum); // 0.3

        // 减法
        BigDecimal difference = num2.subtract(num1);
        System.out.println("0.2 - 0.1 = " + difference); // 0.1

        // 乘法
        BigDecimal product = num1.multiply(new BigDecimal("2"));
        System.out.println("0.1 * 2 = " + product); // 0.2

        // 除法（指定舍入模式）
        BigDecimal quotient = new BigDecimal("1").divide(new BigDecimal("3"), 2, RoundingMode.HALF_UP);
        System.out.println("1 / 3 = " + quotient); // 0.33

        // 设置小数位数
        BigDecimal num3 = new BigDecimal("3.1415926");
        BigDecimal scaledNum = num3.setScale(2, RoundingMode.HALF_UP);
        System.out.println("保留2位小数：" + scaledNum); // 3.14
    }
}

五、正则表达式

正则表达式是一种用于描述字符串模式的工具，它可以高效地进行字符串的匹配、查找、替换等操作。

1. 常用元字符及示例

元字符	含义	示例	匹配结果
.	匹配任意单个字符（除换行）	a.b	aab、acb、a1b
*	匹配前面子表达式 0 次或多次	ab*c	ac、abc、abbc
+	匹配前面子表达式 1 次或多次	ab+c	abc、abbc
?	匹配前面子表达式 0 次或 1 次	ab?c	ac、abc
[]	字符集	[abc]	a、b、c
()	分组	(ab)+	ab、abab
\|	或	a\|b	a、b
^	开始位置	^abc	abc（字符串开头）
$	结束位置	abc$	abc（字符串结尾）
\d	数字	\d{3}	123、456
\w	字母、数字、下划线	\w+	hello、user123

2. 正则表达式在 Java 中的使用代码

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TestRegex {
    public static void main(String[] args) {
        // 1. 匹配手机号（11位，以1开头，第二位3-9）
        String phone = "13800138000";
        boolean isPhone = phone.matches("1[3-9]\\d{9}");
        System.out.println("是否为手机号：" + isPhone);

        // 2. 匹配邮箱（增强版：支持多级域名和下划线）
        String email = "test.user_name@mail.example.co.uk";
        boolean isEmail = email.matches("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*");
        System.out.println("是否为邮箱：" + isEmail);

        // 3. 拆分字符串（处理连续分隔符）
        String str = "apple,,banana;;orange   grape";
        String[] fruits = str.split("[,;\\s]+"); // +表示匹配1次或多次
        System.out.println("\n拆分结果：");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 4. 替换字符串（按规则替换）
        String text = "Java123Script456Python789C";
        // 替换数字为下划线
        String replacedText1 = text.replaceAll("\\d+", "_");
        System.out.println("\n替换数字为下划线：" + replacedText1);
        
        // 只保留字母
        String replacedText2 = text.replaceAll("[^a-zA-Z]", "");
        System.out.println("只保留字母：" + replacedText2);

        // 5. 提取特定内容（分组提取）
        String log = "用户id:10086,用户名:张三,年龄:25;用户id:10010,用户名:李四,年龄:30";
        Pattern userPattern = Pattern.compile("用户id:(\\d+),用户名:(\\w+),年龄:(\\d+)");
        Matcher userMatcher = userPattern.matcher(log);
        
        System.out.println("\n提取用户信息：");
        while (userMatcher.find()) {
            String id = userMatcher.group(1); // 第1个分组
            String name = userMatcher.group(2); // 第2个分组
            String age = userMatcher.group(3); // 第3个分组
            System.out.println("ID:" + id + ", 姓名:" + name + ", 年龄:" + age);
        }

        // 6. 复杂模式验证（身份证号）
        String idCard = "110101199001011234";
        boolean isIdCard = idCard.matches("[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[0-9Xx]");
        System.out.println("\n是否为身份证号：" + isIdCard);
    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-07-21，如有侵权请联系 cloudcommunity@tencent.com 删除

object