Java常用类库

cheniy2025/9/17大约 8 分钟

Java常用类库

1. StringBuffer类

String 类和 StringBuffer 类平级
String 不能改变内容，否则会改变地址，StringBuffer 则可以改变

常用方法：

提示：StringBuilder类

StringBuilder 类定义结构和 StringBuffer 类完全一致
唯一区别在于：在源代码中 StringBuffer 中的方法全是用 synchronized（同步）修饰，所有 StringBuilder 中的方法全是异步方法

面试：解释String，StringBuffer和StringBuilder的区别？

String 一旦申明则不可改变，其他两个可以
StringBuffer 中提供的方法是同步方法，属于安全的线程操作，而 StringBuilder 中是异步方法，属于非安全的线程操作

2. Runtime类

Runtime 类表示运行时的操作类，是封装了 JVM 进程的类

每一个 JVM 都对应着一个 Runtime 的实例，此实例由 JVM 运行时为其实例化
Runtime 类本身没有构造方法，因为它构造方法私有化（单例模式）

// 通过静态方法获取实例
Runtime run = new Runtime.getRuntime();

常用方法：

3. System类

System 类是一些系统相关的属性和方法的集合
System 类中所有的属性和方法都是静态的，由类直接调用

常用方法：

补充：对象的生命周期

4. 日期操作类

4.1 Date类

构造方法：public Date() ，public Date(long date)
将 Date 变为 long：public long getTime()
可以使用 Calendar 类完成操作或利用 SimpleDateFormat 类进行格式化显示

public class dome01 {
    public static void main(String[] args) {
        Date date = new Date();
        // date转long
        long longDate = date.getTime();
        System.out.println(date);
        System.out.println(longDate);
        // 使用long构造转换为Date
        System.out.println(new Date(longDate));

    }
}

/*运行结果；
Mon Jan 20 14:16:43 CST 2025
1737353803294
Mon Jan 20 14:16:43 CST 2025
*/

4.2 Calendar类

Calendar 类可以精确到毫秒
Calendar 类本身是抽象类，需要子类进行实例化（GregorianCalendar 类）

4.3 DateFormat类

Format 的子类，用于将时间格式化为国人习惯的类型
只是格式化的工具类，需要传入原始时间才能进行输出格式化

public class dome01 {
    public static void main(String[] args) {

        // 获取实例化对象
        DateFormat dateFormat1 = DateFormat.getDateInstance();
        // 显示具体时间
        DateFormat dateFormat2 = DateFormat.getDateTimeInstance();

        // 传入需要格式化的时间
        System.out.println(dateFormat1.format(new Date()));
        System.out.println(dateFormat2.format(new Date()));


        // 指定显示风格：
        DateFormat dateFormat3 = DateFormat.getDateTimeInstance(
                DateFormat.YEAR_FIELD,
                DateFormat.ERA_FIELD,
                new Locale("zh","CN")
        );
        System.out.println(dateFormat3.format(new Date()));
    }
}

/*
2025年1月20日
2025年1月20日 下午3:11:44
2025年1月20日 中国标准时间 下午3:11:44
*/

4.4 SimpleDateFormat类

转换不同日期格式，如：2025-1-15 转换为 2025年1月15日

public class dome01 {
    public static void main(String[] args) throws Exception {
        // 定于需要转换的日期格式
        String part2="yyyy 年 MM 月 dd 日 HH 时 mm 分 ss 秒 SSS 毫秒";
        // 传入模版进行实例化
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat(part2);
        // 传入date根据创造模版的进行转换
        System.out.println(simpleDateFormat2.format(new Date()));

    }
}

/*
2025 年 01 月 20 日 15 时 25 分 54 秒 466 毫秒
*/

String转Date

public class dome01 {
    public static void main(String[] args) throws Exception {

        // 模拟需要转化的时间格式
        String dateTime="2025-01-15 15:20:12.166";
        // 定于原始日期格式
        String part1="yyyy-MM-dd HH:mm:ss.SSS";
        // 传入模版进行实例化
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat(part1);
        // 转换为Date格式
        Date date = simpleDateFormat1.parse(dateTime);
        System.out.println(date);
    }
}

/*
Wed Jan 15 15:20:12 CST 2025
*/

5. Random类

随机生成数据

6. NumberFormat类

对较大的数字进行格式化

public class dome01 {
    public static void main(String[] args) throws Exception {
        NumberFormat instance = NumberFormat.getInstance();
        System.out.println(instance.format(1000000));
    }
}

/*
1,000,000
*/

7. DecimalFormat类

NumberFormat 类的子类，可以自定义格式化数字

public class dome01 {
    public static void main(String[] args){

        format("###,###.###",111222.34567);
        format("000,000,000",111222.34567);
        format("###,###.###$",111222.34567);
        format("##.###%",0.34567);
        format("00.###%",0.034567);
        format("##.###%",0.034567);
        // 千分数
        format("###.###\u2030",0.34567);
        
    }

    public static void format(String str,double value){
        // 使用模版实例化DecimalFormat
        DecimalFormat decimalFormat = new DecimalFormat(str);
        // 进行格式化输出
        System.out.println(decimalFormat.format(value));
    }

}

8. BigInteger类

对于整数处理大于 long 的数字

9. BigDecimal类

对于小数处理大于 double 的数字
注意：要指定四舍五入的小数位需要自己修改

public class dome01 {
    public static void main(String[] args){
        BigDecimal b1 = new BigDecimal("12.452421");
        myRound(b1,2);
    }
    // 利用除法进行四舍五入
    public static void myRound(BigDecimal b,int len){
        BigDecimal bigDecimal = new BigDecimal(1);
        // 除法，参数分别为：被除数，小数长度，四舍五入申明标识
        System.out.println(b.divide(bigDecimal, len, RoundingMode.HALF_UP));

    }
}

/*
12.45
*/

10. 对象克隆技术

子类实现 Cloneable 接口后，直接使用 Object 类中的 clone() 方法
使用前需要子类覆写该方法，并扩大访问权限

// 实现接口Cloneable
public class User implements Cloneable {
    private String name;
    private Integer age;
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    // 覆写克隆方法
    public User clone() {
        try {
            return (User) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    public String toString() {
        return "User{" + "name='" + name + "'" + ", age=" + age + '}';
    }
}

public class dome01 {
    public static void main(String[] args){
        User user = new User("zhangsan",18);
        User cloneUser = user.clone();
        // 克隆后形成两个地址
        cloneUser.setName("lisi");
        System.out.println(user);
        System.out.println(cloneUser);
    }
}

11. Array类

主要涉及数组元素的查找，填充，排序

12. 比较器

12.1 comparable接口

用于比较对象，进行排序，需要比较的对象实现该接口
大于：1，小于：-1，等于：0

// 实现接口Comparable<T>
public class User implements Comparable<User> {

    private String name;
    private Integer age;
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public String toString() {
        return "User{" + "name='" + name + "'" + ", age=" + age + '}';
    }
    // 比较器，正常大于为1，则为升序，反之-1则为降序
    public int compareTo(User o) {
        if (this.age>o.age) return 1;
        else if (this.age<o.age) return -1;
        else return 0;
    }
}

public class dome01 {
    public static void main(String[] args){

        User user1 = new User("zhangsan1",18);
        User user2 = new User("zhangsan2",15);
        User user3 = new User("zhangsan3",45);
        User[] user ={user1,user2,user3};

        // 使用Arrays.sort进行排序
        Arrays.sort(user);
        for (User u:user){
            System.out.println(u);
        }
    }
}

12.2 Comparator接口

单独指定一个规则比较类，排序时使用，不需要需要比较的类中实现
是对没设置 Comparable 类的补救方法

public class MyComparator implements Comparator<User> {

    // 定义比较规则
    @Override
    public int compare(User user1, User user2) {
        if (user1.getAge()>user2.getAge()) return 1;
        else if (user1.getAge()<user2.getAge()) return -1;
        else return 0;
    }
}

public class dome01 {
    public static void main(String[] args){

        User user1 = new User("zhangsan1",18);
        User user2 = new User("zhangsan2",15);
        User user3 = new User("zhangsan3",45);
        User[] user ={user1,user2,user3};

        // 使用Arrays.sort进行排序，第二个参数为自定义比较规则
        Arrays.sort(user,new MyComparator());
        for (User u:user){
            System.out.println(u);
        }
    }
}

请解释Comparable和Comparator的区别

两者都是实现对对象比较的接口，都需要使用 Arrays.sort 才能进行排序
Comparable 是在类定义时实现该接口，并重写 compareTo 方法来指定比较规则
Comparator 是在类定义完之后，自己编写比较规则类来实现该接口，然后再排序时使用自己定义的规则类，属于挽救式的比较方法

13. 观察者设计模式

观察者模式类似于数据监听的操作，对某些数据发生变化时立刻做出响应
当被观察者设置的观察点发生变化则通知观察者发生反应
被观察的类继承 Observable 类
观察类实现 Observer 接口

// 被观察者
public class School extends Observable {
    private String info;
    public School(String info) {this.info = info;}
    public void setInfo(String info) {
        // 设置变化点
        super.setChanged();
        // 通知所有观察者（参数为通知内容）
        super.notifyObservers(info);
        this.info = info;
    }
    public String toString() {
        return "School{" + "通知：" + info + '}';
    }
}

// 观察者
public class Student implements Observer {
    private String name;
    public Student(String name) {this.name = name;}
    // 参数分别为：被观察类的实例，传递过来通知的内容
    public void update(Observable o, Object arg) {
        if (arg instanceof String){
            System.out.println("学生："+this.name+"收到通知："+(String) arg);
        }
    }
}

public class dome01 {
    public static void main(String[] args){

        School school = new School("无通知");
        // 实例化观察者
        Student stu1 = new Student("张三");
        Student stu2 = new Student("李四");
        Student stu3 = new Student("王五");
        // 进行观察
        school.addObserver(stu1);
        school.addObserver(stu2);
        school.addObserver(stu3);
        // 当前通知
        System.out.println(school);
        // 修改通知：此时观察者会收到信息
        school.setInfo("明天不上学！");
        System.out.println(school);
    }
}

/*
School{通知：无通知}
学生：王五收到通知：明天不上学！
学生：李四收到通知：明天不上学！
学生：张三收到通知：明天不上学！
School{通知：明天不上学！}
*/

14. 正则表达式

String 类对正则表达式的支持（Pattern 类和 Matcher 类了解书P360）

15. 定时调度

需要用到两个类 Timer（设置定时形式）和 TimerTask（设置执行任务）

schedule和scheduleAtFixedRate的区别：

schedule 方法：执行的时间间隔永远是固定的，出现延迟下次也会相同时间执行
scheduleAtFixedRate 方法：可以根据延迟自动调整下一次执行的时间

// 任务
public class MyTask extends TimerTask {
    // 设置执行任务
    public void run() {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("现在的时间为；"+format.format(new Date()));
    }
}

public class dome01 {
    public static void main(String[] args){
        // 实例化Timer
        Timer timer = new Timer();
        // 实例化任务
        MyTask myTask = new MyTask();
        // 为timer设置任务，设置间隔时间（1000ms后执行，此后间隔2000ms执行）
        timer.schedule(myTask,1000,2000);
    }
}

/*
现在的时间为；2025-01-20 22:24:21
现在的时间为；2025-01-20 22:24:23
现在的时间为；2025-01-20 22:24:25
现在的时间为；2025-01-20 22:24:27
现在的时间为；2025-01-20 22:24:29

*/