第十二天:Object(s),Date,DateFormat,Calendar,System,StringBuilder类

一.Object类

(一)概述

java.lang.Object类是Java语言中的，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。
如果一个类没有特别指定父类， 那么默认则继承自Object类。例如：

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

(二)Object类常用方法

1.toString方法

• public String toString()：返回该对象的字符串表明。

toString方法返回该对象的字符串表明，实则该字符串内容就是对象的类型+@+内存地址值。
代码:
Person.java

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

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

ToStringTest.java

public class ToStringTest {
    public static void main(String[] args) {
        /*
        Person类默认继承了object类,所以可以使用object类中的tostring方法
        String tostring() 返回该对象的字符串表明。
        */
        Person person = new Person("张三", 18);
        System.out.println(person); // cn.cxy.demo12.test1.Person@3feba861
        System.out.println(person.toString()); // cn.cxy.demo12.test1.Person@3feba861
    }
}

运行结果:

由于toString方法返回的结果是内存地址，而在开发中，常常需要按照对象的属性得到相应的字符串表现形式，因此需要重写它。

代码:
Person.java

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

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    /*
    直接打印对象的地址值没有意义。需要重写0bjec t类中的tostring方法
    打印对象的属性(name, oge)
    */
    @Override
    public String toString() {
        return "Person{" +
                "name= " + name +     +
                ", age=" + age +
                 } ;
    }
}

ToStringTest.java

public class ToStringTest {
    public static void main(String[] args) {
        /*
        Person类默认继承了object类,所以可以使用object类中的tostring方法
        String tostring() 返回该对象的字符串表明。
        */
        Person person = new Person("张三", 18);
        // 已重写了toString方法
        System.out.println(person); // Person{name= 张三 , age=18}
        System.out.println(person.toString()); // Person{name= 张三 , age=18}
    }
}

运行结果:

2.equals方法

• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

equals源码:

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

参数:
object obj: 可以传递任意的对象
==比较运算符。近回的是一个布尔值true false

• 基本数据类型:比较的是值
• 引用数据类型:比价的是两个对象的地址值

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是一样的。这里的“一样”有默认和自定义两种方式。

(1) 默认地址比较
如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。
代码:
Person.java

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

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

EqualTest.java

public class EqualTest {

    public static void main(String[] args) {
        Person p1 = new Person("迪丽热巴", 18); // cn.cxy.demo12.test3.Person@3feba861
        Person p2 = new Person("迪丽热巴", 18); // cn.cxy.demo12.test3.Person@5b480cf9
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p1.equals(p2)); // false

        p1 = p2;
        System.out.println(p1.equals(p2)); // true
    }
}

运行结果:

(2) 对象内容比较
如果希望进行对象的内容比较，即所有或指定的部分成员变量一样就判定两个对象一样，则可以覆盖重写equals方法。
代码:
Person.java

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

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    // 手动重写equals方法
    /*@Override
    public boolean equals(Object obj) {
        // 增加一个判断,传递的参数如果是this本身,直接返回true,提高程序效率
        if (this == obj) {
            return true;
        }
        // 增加一个判断,传递的参数obj如果是null,直接返回false,提高程序效率
        if (obj == null) {
            return false;
        }
        // 增加一个判断,防止类型转换异常ClassCastException
        if (obj instanceof Person) {
            // 使用向下转型,把obj转换为Person类型
            Person person = (Person) obj;
            boolean b = this.name.equals(person.name) && this.age == person.age;
            return b;
        }
        // 不是Person类型,直接返回false
        return false;
    }*/

    // 自动生成equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        // getClass() != o.getClass() 使用反射技术,判断o是否为Person类型
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Person person = (Person) o;
        // Objects.equals(name, person.name) 对两个对象进行比较，防止空指针异常
        return age == person.age &&
                Objects.equals(name, person.name);
    }

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

EqualsTest.java

public class EqualsTest {
    public static void main(String[] args) {
        Person p1 = new Person("迪丽热巴", 18); // cn.cxy.demo12.test3.Person@3feba861
        Person p2 = new Person("迪丽热巴", 18); // cn.cxy.demo12.test3.Person@5b480cf9
        Person p3 = new Person("古力娜扎", 20); // cn.cxy.demo12.test4.Person@6f496d9f
        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);

        System.out.println(p1.equals(p2)); // true
        System.out.println(p1.equals(p3)); // false
        System.out.println(p1.equals(p1)); // true
        System.out.println(p1.equals(null)); // false
    }
}

运行结果:

二.Objects类

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表明形式、比较两个对象。

(一)Objects类中的equals方法

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

• public static boolean equals(Object a, Object b)：判断两个对象是否相等。

源码:

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

代码:

public class ObjectsEqualsTest {
    public static void main(String[] args) {
        String str1 = "aaa";
        String str2 = "aaa";
        String str3 = null;
        String str4 = null;
        // 可以容忍空指针
        System.out.println(Objects.equals(str1,str2));
        System.out.println(Objects.equals(str1,str3));
        System.out.println(Objects.equals(str3,str4));
    }
}

三.Date类

(一)概述

• java.util.Date类 表明特定的瞬间，准确到毫秒。

继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把时间戳转成日期对象。

(二)构造方法

• public Date()：分配Date对象并初始化此对象，以表明分配它的时间（准确到毫秒）。
• public Date(long date)：分配Date对象并初始化此对象，以表明自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

tips: 由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。

注意事项:在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。

(三)常用方法

• public long getTime() 把日期对象转换成对应的时间毫秒值(时间戳)。

代码:

public class DateTest {
    public static void main(String[] args) {
        /*
        Date类的空参数构造方法
        Date()获取当前系统的日期和时间
        */
        Date date = new Date();
        System.out.println("目前的时间为: " + date);

        // 返回自1970年1月1日00:00:00 GMT以来此Date对象表明的毫秒数。
        Long timestamp = date.getTime();
        System.out.println("目前的时间对应的时间戳为: " + timestamp); // 返回时间戳

        // Date(Long date) :传递毫秒值, 把毫秒值转换为Date日期
        Date date0L = new Date(0L);
        System.out.println("时间戳0L对应的时间为: " + date0L); // Thu Jan 01 08:00:00 CST 1970

        Date dateMyTime = new Date(1616140892468L);
        System.out.println("时间戳1616140892468L对应的时间为: " + dateMyTime); // Fri Mar 19 16:01:16 CST 2021
    }
}

运行结果:

四.DateFormat类

(一)概述

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

• 格式化：按照指定的格式，从Date对象转换为String对象。
• 解析：按照指定的格式，从String对象转换为Date对象。

(二)构造方法

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

• public SimpleDateFormat()：用默认的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
• public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

参数pattern是一个字符串，代表日期时间的自定义格式。

(三)格式规则

| 标识字母（区分大小写） |   含义  |
| y                    |   年    |
| M                    |   月    |
| d                    |   日    |
| H                    |   时    |
| m                    |   分    |
| s                    |   秒    |

写对应的模式。会把模式替换为对应的日期和时间:yyyy-MM-dd HH:mm:ss

(四)常用方法

• public String format(Date date)：将Date对象格式化为字符串。
• public Date parse(String source)：将字符串解析为Date对象。
  代码:

public class DateFormatTest {
    public static void main(String[] args) {
        Date date = new Date();
        // 按照默认的模式构造SimpleDateFormat
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        System.out.println(sdf1.format(date));

        // 按照自定义的模式构造SimpleDateFormat
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf2.format(date));
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        System.out.println(sdf3.format(date));

        // 按照自定义的模式解析SimpleDateFormat
        SimpleDateFormat sdf4 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        try {
            System.out.println(sdf4.parse("2021年03月19日 16时56分19秒"));
        }catch (ParseException ignored){
            System.out.println("格式异常!");
        }
    }
}

运行结果:

五.Calendar类

(一)概述

java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

(二)创建对象静态方法

Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象，如下：

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

(三)常用方法

• 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对象。
• public void setTime(Date date)：使用给定的 Date 设置此 Calendar 的时间。

(四)成员常量

Calendar类中提供许多成员常量，代表给定的日历字段：
| 字段值          | 含义
| YEAR           | 年 
| MONTH          | 月（从0开始，可以+1使用）
| DAY_OF_MONTH   | 月中的天（几号）
| HOUR           | 时（12小时制）
| HOUR_OF_DAY    | 时（24小时制）
| MINUTE         | 分  
| DAY_OF_WEEK    | 周中的天（周几，周日为1，可以-1使用

小贴士：
西方星期的开始为周日，中国为周一。
在Calendar类中，月份的表明是以0-11代表1-12月。
日期是有大小关系的，时间靠后，时间越大。

代码:

public class CalendarTest {
    public static void main(String[] args) {
        /*
        int field:日历类的字段，可以使用calendar类的静态成员变量获取
        public static final int YEAR = 1;   年
        public static final int MONTH = 2;  月
        public static final int DATE = 5;   月中的某一天
        public static final int HOUR = 10;  时
        public static final int MINUTE = 12;    分
        public static final int SECOND = 13;    秒
        */

        Calendar calendar = Calendar.getInstance();
        System.out.print("目前时间是: ");
        getCalendar(calendar); // 2021年3月20日

        calendar = setCalendar(calendar, 2000, 1, 25);
        System.out.print("设置的时间为: ");
        getCalendar(calendar); //2000年1月25日

        // public abstract void add(int field, int amount)增加或减少特定的值
        System.out.print("增加或减少后的的时间为: ");
        calendar.add(Calendar.YEAR, 21);
        calendar.add(Calendar.MONTH, 2);
        calendar.add(Calendar.DATE, -4);
        getCalendar(calendar); //2041年1月25日

        // public Date getTime()返回一个表明此Calendar时间值(从历元到目前的毫秒偏移量)的Date对象。
        Date date = calendar.getTime();
        System.out.print("转化为Date对象: ");
        System.out.println(date);

        // public void setTime(Date date)使用给定的Date设置此 Calendar 的时间
        Calendar calendar1 = Calendar.getInstance();
        calendar1.setTime(new Date());
        System.out.print("目前时间是: ");
        getCalendar(calendar1); //2041年1月25日
    }

    private static Calendar setCalendar(Calendar calendar, int year, int month, int date) {
        /*
        calendar.set(Calendar.YEAR,a);
        calendar.set(Calendar.YEAR,b);
        calendar.set(Calendar.YEAR,c);
         */
        calendar.set(year, month - 1, date);
        return calendar;
    }

    private static void getCalendar(Calendar calendar) {
        // public int get(int field)获取年月日信息
        System.out.print(calendar.get(Calendar.YEAR) + "年");
        System.out.print((calendar.get(Calendar.MONTH) + 1) + "月"); // 西方的月份0~11月,东方的月份1~12月
        System.out.print(calendar.get(Calendar.DATE) + "日");
        System.out.print(calendar.get(Calendar.HOUR) + "时");
        System.out.print(calendar.get(Calendar.MINUTE) + "分");
        System.out.println(calendar.get(Calendar.SECOND) + "秒");
    }
}

运行结果:

六.System类

(一)概述

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，

(二)常用方法：

• public static long currentTimeMillis()：返回以毫秒为单位的当前时间。

代码:

public class SystemTest {
    public static void main(String[] args) {
        Long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        Long end = System.currentTimeMillis();
        System.out.println("程序运行的时间为" + (end - start) + "毫秒");
    }
}

运行结果:

• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

代码:

public class SystemTest {
    public static void main(String[] args) {
        int[] arrayA = {1, 2, 3, 4, 5};
        int[] arrayB = {4, 5, 6, 7, 8};
        // 把A数组中前三个元素复制到B数组中
        System.arraycopy(arrayA, 0, arrayB, 0, 3);
        for (int value : arrayA) {
            System.out.print(value);
        }
        System.out.println();
        for (int value : arrayB) {
            System.out.print(value);
        }
    }
}

运行结果:

七.StringBuilder类

(一)为什么需要字符串缓冲区

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。
根据这句话分析我们的代码，实则总共产生了三个字符串，即"Hello"、"World"和"HelloWorld"。引用变量s第一指向Hello对象，最终指向拼接出来的新字符串对象，即HelloWord 。

(二)概述

查阅java.lang.StringBuilder的API，StringBuilder又称为可变字符序列，它是一个类似于String的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。
原来StringBuilder是个字符串的，即它是一个容器，容器中可以装许多字符串。并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)

(二)构造方法

• public StringBuilder()：构造一个空的StringBuilder容器。
• public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

(三)常用方法

• public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
• public String toString()：将当前StringBuilder对象转换为String对象。

代码:

public class StringBuilderTest {
    public static void main(String[] args) {
        // 构造StringBuilder对象
        StringBuilder sb1 = new StringBuilder();
        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println("sb1: " + sb1);
        System.out.println("sb2: " + sb2);

        // 向sb1中添加字符串Hello
        sb1.append("Hello");
        System.out.println("sb1 append "Hello": " + sb1);

        // 将StringBuilder对象转化为String对象
        String str = sb1.toString();
        System.out.println("str: " + str);
    }
}

运行结果:

(四)链式编程

在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法，这种时候，我们就可以把代码写在一起。
代码:

public class StringBuilderTest2 {
    public static void main(String[] args) {
        // 构造StringBuilder对象
        StringBuilder sb1 = new StringBuilder();

        // 向sb1中添加字符串Hello
        sb1.append("Hello")
                .append(" World,")
                .append("Hello")
                .append(" cxy!");
        System.out.println(sb1);
    }
}

运行结果:

八.包装类

(一)概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，不过许多情况，会使用，由于对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

(二)装箱与拆箱

• 装箱：从基本类型转换为对应的包装类对象。
• 拆箱：从包装类对象转换为对应的基本类型。

以Integer->int和int->Integer为例：
以Integer->String和String->Integer为例：

• public static valueOf(int i)：返回一个表明指定的 int 值的 Integer 实例。
• public static valueOf(String s)：返回保存指定的 String 的值的 Integer 对象。
• public int intValue()：以 int 类型返回该 Integer 的值。
• public String toString()：返回一个表明该 Integer 值的 String 对象。

代码:

public class IntegerTest {
    public static void main(String[] args) {
        // 装箱
        Integer integer1 = Integer.valueOf(1);
        Integer integer2 = Integer.valueOf("10");
        System.out.println("Integer: " + integer1);
        System.out.println("Integer: " + integer2);

        // 拆箱
        int i = integer1.intValue();
        String str = integer2.toString();
        System.out.println("int: " + i);
        System.out.println("String: " + str);
    }
}

运行结果:

(三)自动装箱与自动拆箱

由于我们常常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。
以Integer->int和int->Integer为例：
代码:

public class IntegerTest {
    public static void main(String[] args) {
        // 自动装箱。相当于Integer integer = Integer.valueOf(3);
        Integer integer = 3;
        // 等号右边：将i对象转成基本数值(自动拆箱) integer.intValue() + 2;
        int i = integer + 2;
        System.out.println("Integer: " + integer);
        System.out.println("int: " + i);

        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(i);
        int i2 = arrayList.get(0);
        System.out.println("int: " + i2);
    }
}

运行结果:

(四)基本类型与字符串之间的转换

1.基本类型转换为字符串

以int->String为例：

• 基本类型的值+””最简单的方法(工作中常用)
• 包装类的静态方法:public static String toString(int i)返回一个表明指定整数的String 对象。
• String类的静态方法:public static String valueOf(int i)返回int参数的字符串表明形式。

2.字符串转换为基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

• public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
• public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
• public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
• public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。
  代码（仅以Integer类的静态方法parseInt为例）:

public class IntegerToString {
    public static void main(String[] args) {
        // 基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1 + "";
        System.out.println(s1 + 200);

        int i2 = 100;
        String s2 = Integer.toString(i2);
        System.out.println(s2 + 200);

        int i3 = 100;
        String s3 = String.valueOf(i3);
        System.out.println(s3 + 200);

        // 字符串(String)->基本类型
        int i4 = Integer.parseInt("100");
        System.out.println(i4 + 200);

        // char->字符串(String)
        char ch =  a ;
        String str = ch+"";
        System.out.println(str);
        // 字符串(String)->char
        char ch1 = str.charAt(0);
        System.out.println(ch1);
    }
}

运行结果:

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

(五)三种类型之间的相互转换