Java进阶—Object&Objects、Date、DateFormat&SimpleDateFormat、Calendar、System&StringBuilder、包装类

一、Object类

1.概述
类Object是类层次结构的根类。每个类都使用Object作为超类（父类）。所有对象（包括数组）都实现这个类的方法、
一个类都会直接或间接的继承自该类。

Object类中的toString()方法，默认打印的是对象的地址值。如果希望打印对象的属性，则需要覆盖重写该方法。

2.toString()方法
直接打印对象的名字，其实就是调用对象的toString方法。

看一个类是否重写了toString方法，直接打印这个类对应对象的名字即可：

如果没有重写toString方法，那么打印的就是对象的地址值（默认值）。

如果重写了toString方法，那么就按照重写的方式打印。

总结：

作用：打印对象的信息

重写前：打印的是包名类名@地址值

重写后：打印的是对象中的属性值

2.equals()方法

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

方法源码：

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

参数：(是Object类型)
    Object obj：可以传递任意的对象
方法体：
    ==:比较运算符，返回的就是一个布尔值：true 、false
    【基本数据类型】比较的是【值】
    【引用数据类型】比较的是【地址值】
this：哪个对象调用的方法，方法中的this就是哪个对象。

注意事项：

Object类的equals方法，会有一定的弊端，如果一个字符串为空值null，则使用对象的equals方法时，会抛出空指针异常（NullPointerException）

原因分析：null是不能调用方法的

解决方案：采用Objects类的equals方法

总结：

作用：比较两个对象

重写前：比较的是对象的地址值

重写后：比较的是对象的属性值（成员变量）

3.覆盖重写toString()方法和equals()方法

比较两个对象的地址值，没有意义，我们希望比较的是两个对象的属性值，如果属性值一样，返回true，否则返回false。

//覆盖重写toString方法
@Override
public String toString() {
	return "Person{" +
	"name='" + name + '\'' +
	", age=" + age +
	 '}';
}

//覆盖重写equals方法
@Override
public boolean equals(Object o) {
    if (this == o) return true; // 提高代码效率
    // getClass() != o.getClass())，使用反射技术，判断o是否为Person类型
    // 等效于if(obj instanceof Person)
    if (o == null || getClass() != o.getClass()) return false;  // 提高代码效率
    Person person = (Person) o; // 对象向下转型（强转）
    return age == person.age && Objects.equals(name, person.name);
}

String类中，覆盖重写了equals()方法，比较的就是两个字符串对象的内容是不是一样的。

对于自己定义的类，则默认调用的是Object类中的equals方法，如果想要比较对象的属性值，需要覆盖重写equals方法。

二、Objects类

1.概述
Objects类，他提供了一些方法来操作对象，它由一些【静态的使用方法组成】，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表现形式、比较两个对象。

2.Objects类equals方法的空指针优化

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

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

Objects类equals方法源码：（默认比较的是两个对象的地址值）

Objects类的equals方法：对两个对象进行比较，【防止空指针异常】。

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

总结：

避免了Object类中equals()方法的空指针异常问题

三、Date类

1.java.util.Date
表示日期和时间的类；表示特定的瞬间，精确到毫秒。

毫秒值的作用：

可以对时间和日期进行计算。

可以把日期转换为毫秒值进行计算，计算完毕后，再把毫秒值转换为日期。

把日期转换为毫秒：

【时间原点（0毫秒）】：1970年1月1日 00:00:00（英国格林威治）

就是计算当前日期到时间原点之间一共经历了多少毫秒(为Long类型)

注意：中国属于东八区，会把时间增加8个小时

把毫秒转换为日期：

1天 = 24 * 60 * 60 = 86400秒 = 86400 * 1000 = 86400000毫秒

2.Date类的构造方法和成员方法

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

2.有参构造方法：传递毫秒值，把毫秒值转换为日期
  Date(long time);

3.成员方法：
	Long getTime(),把系统当前日期转换为毫秒，相当于System.currentTimeMillis()
	
	String toLocalString();    根据本地格式转换日期对象

实例分析：

//Date()获取的就是当前系统的日期和时间
Date date = new Date();

//Date(long date):传递毫秒值，把毫秒值转换为Date日期
Date date2 = new Date(0L);

//Long getTime():返回自1970年1月1日00:00:00 GMT以来此Date对象表示的毫秒数
//其实就是把日期转换为毫秒，相当于System.currentTimeMillis()
Date date3 = new Date();
long time = date3.getTime();

四、DateFormat类

1.概述
java.text.DateFormat:是时间/日期格式化子类的抽象类。

作用：

1.格式化：也就是日期 --> 文本

2.解析：文本 --> 日期

2.成员方法

1.String format(Date date):按照指定的模式，把Date日期，格式化为符合模式的字符串

2.Date parse(String source):把符合模式的字符串，解析为Date日期。

3.SimpleDateFormat

DateFormat类是一个【抽象类】，无法直接创建对象使用，
可以使用DateFormat的【子类】：
java.text.SimpleDateFormat extends DateFormat

构造方法：

SimpleDataFormat(String pattern):用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat.

参数：String pattern:传递指定的模式

模式：区分大小写，常用格式为
    y               年
    M               月
    d               日
    H               时
    m               分
    s               秒
    
写对应的模式，会把模式替换为对应的日期和时间
    "yyyy-MM-dd HH-mm-ss"
    "yyyy年MM月dd日 HH时mm分ss秒"
注意：
    模式中的字母【不能更改】，连接模式的符号【可以更改】

DateFormat类中format方法使用步骤：

1.创建SimpleDateFormat对象，构造方法中传递指定的模式

2.调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本）

实例分析：

//创建SimpleDateFormat对象，构造方法中传递指定的模式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

//调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串（文本）
Date date = new Date();
String text = sdf.format(date);

DateFormat类中parse方法使用步骤：

1.创建SimpleDateFormat对象，构造方法中传递指定的模式

2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串（文本）转化为Date日期

注意事项：

public Date parse(String source) throws ParseException

parse方法声明了一个异常叫做【ParseException】解析异常

如果字符串和构造方法中的模式不一样，那么程序就会抛出此异常
【解决方案】：
  调用一个抛出了异常的方法，就必须要处理这个异常，要么throws继续声明抛出这一个异常，要么try...catch自己处理这个异常

实例分析：

// 1.创建SimpleDateFormat对象，构造方法中传递指定的模式
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

// 2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中模式的字符串（文本）转化为Date日期
Date date = sdf2.parse("2021-10-06 09:47:24");

五、Calendar类

1.java.util.Calendar类：日历类

Calendar类是一个抽象类，里边提供了很多操作日历字段的方法(YEAR、MONTH、DAY_OF_MONTH、HOUR)

Calendar类无法直接创建对象使用，里边有一个静态方法叫getInstance()、该方法返回了Calendar类的子类对象

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

实例分析：

Calendar c = Calendar.getInstance();// 【多态写法】，返回Calendar类的一个子类对象
System.out.println(c);  //打印的不是地址值，说明getInstance()方法重写了toString()方法

2.成员方法

Calendar类的成员方法：

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

成员方法的参数：

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 DATE_OF_MONTH = 5;      月中的某一天
public static final int HOUR = 10;              时
public static final int MINUTE = 12;            分
public static final int SECOND = 13;            秒

实例分析：

Calendar c = Calendar.getInstance();    // 使用getInstance()方法获取Calendar对象
int year = c.get(Calendar.YEAR);
System.out.println(year);   // 2021

注意事项：

Date类的getTime()方法。是将Date格式的时间转换为毫秒

Calendar类的getTime()方法，是将日历对象转换为日期对象

六、System类

1.java.lang.System
类中提供了大量的【静态方法】，可以获取与系统相关的信息或系统级操作，常用的方法有：

    1.public static long currentTimeMillis():返回以毫秒为单位的当前时间

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

2.public static long currentTimeMillis()
作用：
可以用来测试程序的执行效率。程序执行前，获取一次毫秒值；程序执行后，再获取一次毫秒值。

3.public static void arraycopy(Object src, int srcPos, Object dest, int desPos, int length)

参数：

src - 源数组

srcPos - 源数组中的起始位置

dest - 目标数组

destPos - 目标数组中的起始位置

length - 要复制的数组元素的数量。

七、StringBuilder类

1.String类
字符串是常量；它们的值在创建之后不能更改。字符串底层是一个被final修饰的数组，不能改变，是一个常量private final byte[] value;

进行字符串的相加，内存中就会有多个字符串，占用空间多，效率低下。

例如：
String s = “a” + “b” + “c” 结果是：“abc”

但是，【在内存中会出现5个字符串】：
首先由"a",“b”,“c"三个字符串
然后 “a” + “b” 产生了第四个字符串"ab”
然后 “ab” + “c” 产生了第五个字符串"abc"
所以，效率低下。

2.java.lang.StringBuilder

2.1.概念
字符串缓冲区，可以提高字符串的操作效率。【可以看成是一个长度可以变化的字符串】。

底层也是一个数组，但是没有被final修饰，所以可以改变长度。
byte[] value = new byte[16]; // 数组的初始容量长度是16

“a” + “b” + “c” = “abc”
StringBuilder类在内存中始终是一个数组，占用空间少，效率高，如果超出了StringBuilder的容量，会自动的扩容。

2.2.构造方法

public StringBuilder():构造一个空的StringBuilder容器。

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

2.3.成员方法

public StringBuilder append(...):添加任意类型数据的字符串形式，并【返回当前对象自身】。
参数：
    可以是任意的数据类型
注意：
    使用append()方法【无需接收返回值】

StringBuilder reverse();        反转内容

String toString();      将缓冲区内容转换为字符串

实例分析：

// 创建一个StringBuilder对象
StringBuilder bu1 = new StringBuilder();

// 使用append()方法，往StringBuilder中添加数据
//append()方法返回的是this，就是调用方法的对象bu1,即当前对象本身
StringBuilder bu2 = bu1.append("abc");
System.out.println(bu1 == bu2); // true,两个地址值是一样的，说明两个对象是同一个对象，这也就是【返回对象自身】的意思。

2.4.链式编程
因为append()方法返回的是一个【对象】，所以可以根据对象【继续调用】方法，即链式编程。

System.out.println("abc".toUpperCase().toLowerCase().toUpperCase())

3.StringBuilder和String可以相互转换

String --> StringBuilder:可以使用StringBuilder的构造方法
    StringBuilder(String str):构造一个字符串生成器，并初始化为指定的字符串内容

StringBuilder --> String:可以使用StringBuilder中的toString()方法
    public String toString():将当前StringBuilder对象转换为String对象。

实例分析：

String str = "Java";

// String --> StringBuilder
StringBuilder bu = new StringBuilder(str);	

// StringBuilder --> String
String s = bu.toString();

八、包装类

1.包装类
基本数据类型的数据，使用起来非常的方便，但是没有对应的方法来操作这些数据。

所以我们可以使用一个类，把基本数据类型的数据包装起来，这个类叫包装类。

在包装类中可以定义一些方法，用来操作基本数据类型的数据。例如Integer类。

例如ArrayList集合只能存储引用数据类型，要想存储基本类型的数据，就需要包装类

2.基本数据类型与包装类
Java中有两个类型系统：基本数据类型和引用数据类型。

使用基本数据类型，效率会很高，但是无法像对象一样来操作基本数据类型数据，所以，有了包装类。

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

3.装箱与拆箱

3.1概念
基本类型与对应的包装类对象之间，来回转换的过程称为“装箱”与“拆箱”：

装箱：从基本类型转换为对应的包装类对象
    构造方法：
        Integer(int value) 构造一个新分配的Integer对象，它表示指定的int值

        Integer(String s) 构造一个新分配的Integer对象，它表示String参数所指示的int值
        注意：传递的字符串，必须是基本类型的字符串，否则会抛出异常。
        "100":正确
        "a":错误，会抛出异常

    静态方法：
        static Integer valueof(int i) 返回一个表示指定的int值的Integer实例。

        static Integer valueof(String s) 返回保存指定的String的值得Integer对象。

拆箱：从包装类对象转换为对应的基本类型
    成员方法：
        int intValue() 以int类型返回该Integer的值。

3.2自动装箱与拆箱
基本类型的数据和包装类之间可以自动的相互转换

自动装箱：直接把int类型的整数赋值给包装类

自动拆箱：i包装类可以自动转换为基本类型的数据

实例分析：

// ArrayList集合无法直接存储整数，可以存储Integer包装类
ArrayList<Integer> list = new ArrayList<>();

list.add(1);    // 这其实就是一个自动装箱的过程，相当于list.add(new Integer(1));

// 原本返回的是Integer类型，但是也可以用int类型接收，
// 这其实就是一个自动拆箱的过程，相当于list.get(0).intValue();
int a = list.get(0);

4.基本类型和字符串之间的转换

基本类型转换为String：（基本类型 --> 字符串）

1.【最简单的方式】就是基本类型直接与""相连接即可；如34 + ""（即加上一个空字符串）
  【常用！！！】
2.使用包装类中的静态方法
  static String toString(int i)  返回一个表示指定整数的String对象（不同于Object类中的toString方法）
3.使用String类中的静态方法
  static String valueof(int i)  返回int参数的字符串表示形式

String类型转换为对应的基本类型：（字符串 --> 基本类型）

除了Character类之外，其他所有【包装类都具有parseXxx静态方法】可以将字符串参数转换为对应的基本类型：
Integer类：static int parseInt(String s)  把字符串参数转换为对应的int基本类型
Double类： static double parseDouble(String s)  把字符串参数转换为对应的double基本类型
...