JAVA--Object、Date、DateFormat、Calendar、System、StringBuilder-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_45806995/article/details/104333857

本文深入讲解Java中的关键类，如Object、Date、DateFormat、Calendar、System及StringBuilder的使用方法与特性，涵盖构造方法、成员方法及其实例演示。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、Object类

java.lang.Object
类 Object 是类层次结构的根(父)类。
每个类(Person，Student…)都使用 Object 作为超(父)类。所有对象（包括数组）都实现这个类的方法。
如果一个类没有特别指定父亲，那么默认则继承自Object类：

public class Person/* extends Object*/{
    //...
}

1.toString方法
方法摘要：public String toString():返回该对象的字符串表示。
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

public class ToString {
    public static void main(String[] args) {
        Person p = new Person("张三", 18);
        //Person类默认继承了Object类，所以可以使用Object类中的toString方法
        String s = p.toString();

        //直接打印对象的名字，其实就是调用对象的toString   p = p.toString();
        System.out.println(s);//Object.Person@4554617c  |

        //直接打印对象的地址值没有意义，需要重写Object类中的toString方法
        //打印对象的属性(name,age)
        System.out.println(s);//Person{name='张三', age=18}
    }
}

在Person类中覆写Object类中的同String方法：

public class Person {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2.equals方法
Person类默认继承了Object类，所以可以使用Object类的equals方法
boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
equals方法的源码：

public boolean equals(Object obj) {
    return (this == obj);
}

参数：Object obj；可以传递任意的对象
this：哪个对象调用的方法，方法中的this就是哪个对象
obj：传递过来的参数
this == obj --> p1 == p2

public class Demo02Equals extends Object{
    public static void main(String[] args) {
        Person p1 = new Person("Ann",18);
        Person p2 = new Person("Cindy",19);

        System.out.println("p1:" + p1);
        System.out.println("p2:" + p2);

        //p1 = p2;//b = true
        boolean b = p1.equals(p2);//this是p1
        System.out.println(b);//false
    }
}

Object类的equals方法，默认比较的是两个对象的地址值，没有意义
所以要重写equals方法，比较两个对象的属性

import java.util.Objects;

public class Person {
    private String name;
    private int age;

  @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        //getClass() != o.getClass()使用反射技术，判断o是否是Person类型，等效于 obj instanceof Person
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }
}

3.Objects类
上面在自动覆写equals代码中，使用到了java.util.Objects类。
在JDK 7添加了Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题，方法如下：

//Objects类的equals方法：对两个对象进行比较，防止空指针异常
public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

public class Objects {
    public static void main(String[] args) {
        String str1 = null;//null是不能调用方法的，就会抛出空指针异常
        String str2 = "abc";
        //System.out.println(str1.equals(str2));//NullPointerException

        boolean b2 = Objects.equals(str1, str2);
        System.out.println(b2);//false
    }
}

二、Date类

java.util.Date是表示日期和时间的类
类 Date 表示特定的瞬间，精确到毫秒。
毫秒：千分之一秒
特定的瞬间：一个时间点。

毫秒值的作用：可以对时间和日期进行计算
可以把日期转换为毫秒进行计算，计算完毕，再把毫秒转换为日期。

时间原点（0毫秒）：1970年1月1日 00：00：00（英国格林威治）
Notice：北京为东八区，要增加八个小时
把日期转换为毫秒：就是计算当前日期到时间原点之间一共经历了多少毫秒(long类型)
把毫秒转换为日期：1天 = 86400秒 = 86400000毫秒

1.Date类的空参数构造方法：
Date()：获取当前系统的日期和时间

2.Date的带参数的构造方法：
Date(long date):传递毫秒值，把毫秒值转换为Date日期

long getTime()：把日期转换为毫秒值(相当于currentTimeMillis()方法)
返回自时间原点以来，此Date对象表示的毫秒数

public class Date {
    public static void main(String[] args) {
        demo01();
        demo02();
    }

    private static void demo02() {
        Date date = new Date(0L);
        System.out.println(date);//Thu Jan 01 08:00:00 CST 1970
    }

    public static void demo01() {
        Date date = new Date();
        System.out.println(date);//Sat Feb 15 21:51:31 CST 2020
    }
}

三、DateFormat类

java.text.DateFormat:是日期/时间格式化子类的抽象类
作用：格式化（也就是日期 -> 文本）、解析（文本-> 日期）和标准化

成员方法：
1.String format(Date date) ：将一个 Date 格式化为日期/时间字符串。
DateFormat 类是一个抽象类，无法直接创建对象使用，可以使用它的子类java.text.SimpleDateFormat

构造方法：
SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
参数：String pattern：传递指定的格式
模式：区分大小写的(写对应的模式，会把模式替换为对应的日期和时间 “yyyy-MM-dd HH:mm:ss”)
Notice:模式中的字母不能更改，连接模式的符号可以改变。

2.Date parse(String source) ：从给定字符串的开始解析文本，以生成一个日期。
Notice:
public Date parse(String source) throws ParseException
parse方法声明了一个异常叫ParseException，如果字符串和构造方法的模式不一样，那么程序就会抛出这个异常。
调用一个抛出了异常的方法，就必须处理这个异常，要么throws继续抛出这个异常，要么try catch自己处理。

public class DateFormat {
    public static void main(String[] args) throws ParseException {
        demo01();
        demo02();
    }

    private static void demo02() throws ParseException {
        //1.创建SimpleDateFormat对象，过早方法中传递指定模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //2.调用parse方法，把符合构造方法中模式的字符串，解析为Date日期
        Date date = sdf.parse("2020年02月16日 16时36分09秒");
        System.out.println(date);
    }

    public static void demo01() {
        SimpleDateFormat sdf = new SimpleDateFormat();

        Date date = new Date();
        String d = sdf.format(date);
        System.out.println(date);//Sun Feb 16 16:31:17 CST 2020
        System.out.println(d);//20-2-16 下午4:32

        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date1 = new Date();
        System.out.println(sdf1.format(date1));//2020年02月16日 16时36分09秒
    }
}

eg：使用日期时间相关的API，计算出一个人已经出生了多少天

public class Test {
    public static void main(String[] args) throws ParseException {
        //使用Scanner类中的方法next获取出生日期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入宁的出生日期：（格式：yyyy-MM-dd）");
        String birthday = sc.next();

        //将birthday解析为Date格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sdf.parse(birthday);

        //将Date格式的出生日期转换为毫秒值
        long birthdayDateTime = birthdayDate.getTime();
        //当前日期的毫秒值
        long todayTime = new Date().getTime();

        long time = todayTime - birthdayDateTime;

        //将毫秒插值转换为天
        System.out.println(time / 1000 / 60 / 60 / 24);
    }
}

四、Calendar类

java.util.Calendar类：日历类
Calendar类是一个抽象类，里面提供了很多操作日历字段的方法(YEAR、MONTH、DAY_OF_MONTH、HOUR )
Calendar类无法直接创建对象使用，里面有一个静态方法getInstance()，该方法返回了Calendar类的子类对象。

static Calendar getInstance() ：使用默认时区和语言环境获得一个日历。

public class Demo05Calendar {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();//多态
        System.out.println(c);
    }
}

Calendar类的常用成员方法：

public int get(int field):返回给定日历字段的值。
public void set(int field, int value):将给定的日历字段设置为给定值。
public abstract void add(int field, int amount):根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime():返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象。

成员方法的参数：
int field :日历类的字段，可以使用Calendar类的静态成员变量获取(YEAR、MONTH、DAY_OF_MONTH、HOUR )
int value :给定字段设置的值

五、System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息，在System类的API文档中，常用的方法有：
1.public static long currentTimeMillis():返回以毫秒为单位的当前时间。
可用来测试程序的效率

2.public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length):从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
参数：
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。

public class System {
    public static void main(String[] args) {
        demo01();
        demo02();
    }
    public static void demo01() {
        long s = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
        long l = System.currentTimeMillis();
        System.out.println("程序共耗时：" + (l - s) + "毫秒");
    }
    public static void demo02() {
        int[] src = {1, 2, 3, 4, 5};
        int[] dest = {6, 7, 8, 9, 10};
        System.arraycopy(src, 0,dest,0,3);
        System.out.println(Arrays.toString(src));//[1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(dest));//[1, 2, 3, 9, 10]
    }
}

六、StringBuilder类

java.lang.StringBuilder类：字符串缓冲区，可以提高字符串的效率
构造方法：
1.StringBuilder() ：构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
2.StringBuilder(String str) ：构造一个字符串生成器，并初始化为指定的字符串内容。

public class StringBuilder {
    public static void main(String[] args) {
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:" + bu1);//bu1:

        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:" + bu2);//bu2:abc
    }
}

StringBuilder的常用方法：
1.StringBuilder append(…):添加任意类型的字符串形式，并返回当前对象自身。
2.String toString():将当前StringBuilder对象转换为String对象。

public class StringBuilder {
    public static void main(String[] args) {
        StringBuilder bu = new StringBuilder();

        //append方法返回的是this，调用方法的对象bu，this==bu
        StringBuilder bu2 = bu.append("abc");//把bu的地址赋给bu2
        System.out.println(bu);
        System.out.println(bu2);
        System.out.println(bu==bu2);//true

        //使用append方法无需接收返回值
        bu.append(123);
        bu.append('H');
        bu.append(true);
        bu.append(987.654);
        System.out.println(bu);

        //链式编程：方法返回值是一个对象，可以继续调用方法
        System.out.println(bu.append(2).append('C').append('中'));
    }
}

String和StringBuilder可以相互转换：

String toString():将当前StringBuilder对象转换为String对象。
StringBuilder(String str):构造一个字符串生成器，并初始化为指定的字符串内容。

public class toString {
    public static void main(String[] args) {
        String str = "Hello";
        System.out.println("str:" + str);//str:Hello
        StringBuilder bu = new StringBuilder(str);
        bu.append("World") ;
        System.out.println("bu:" + bu);//bu:HelloWorld

        String s = bu.toString();
        System.out.println("s:" + s);//s:HelloWorld
    }
}