摘要：類是日期時間格式化子類的抽象類，我們通過這個類可以幫我們完成日期和文本之間的轉換也就是可以在對象與對象之間進行來回轉換。構造方法由于為抽象類，不能直接使用，所以需要常用的子類。

Object類

Date類

DateFormat類

Calendar類

System類

StringBuilder類

包裝類

-[ ] 能夠說出Object類的特點
-[ ] 能夠重寫Object類的toString方法
-[ ] 能夠重寫Object類的equals方法
-[ ] 能夠使用日期類輸出當前日期
-[ ] 能夠使用將日期格式化為字符串的方法
-[ ] 能夠使用將字符串轉換成日期的方法
-[ ] 能夠使用System類的數組復制方法
-[ ] 能夠使用System類獲取當前毫秒時刻值
-[ ] 能夠說出使用StringBuilder類可以解決的問題
-[ ] 能夠使用StringBuilder進行字符串拼接操作
-[ ] 能夠說出8種基本類型對應的包裝類名稱
-[ ] 能夠說出自動裝箱、自動拆箱的概念
-[ ] 能夠將字符串轉換為對應的基本類型
-[ ] 能夠將基本類型轉換為對應的字符串

java.lang.Object類是Java語言中的根類，即所有類的父類。它中描述的所有方法子類都可以使用。在對象實例化的時候，最終找的父類就是Object。

如果一個類沒有特別指定父類， 那么默認則繼承自Object類。例如：

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

根據JDK源代碼及Object類的API文檔，Object類當中包含的方法有11個。今天我們主要學習其中的2個：

public String toString()：返回該對象的字符串表示。

public boolean equals(Object obj)：指示其他某個對象是否與此對象“相等”。

public String toString()：返回該對象的字符串表示。

toString方法返回該對象的字符串表示，其實該字符串內容就是對象的類型+@+內存地址值。

由于toString方法返回的結果是內存地址，而在開發中，經常需要按照對象的屬性得到相應的字符串表現形式，因此也需要重寫它。

如果不希望使用toString方法的默認行為，則可以對它進行覆蓋重寫。例如自定義的Person類：

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

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

    // 省略構造器與Getter Setter
}

在IntelliJ IDEA中，可以點擊Code菜單中的Generate...，也可以使用快捷鍵alt+insert，點擊toString()選項。選擇需要包含的成員變量并確定。如下圖所示：

小貼士： 在我們直接使用輸出語句輸出對象名的時候,其實通過該對象調用了其toString()方法。

public boolean equals(Object obj)：指示其他某個對象是否與此對象“相等”。

調用成員方法equals并指定參數為另一個對象，則可以判斷這兩個對象是否是相同的。這里的“相同”有默認和自定義兩種方式。

如果沒有覆蓋重寫equals方法，那么Object類中默認進行==運算符的對象地址比較，只要不是同一個對象，結果必然為false。

如果希望進行對象的內容比較，即所有或指定的部分成員變量相同就判定兩個對象相同，則可以覆蓋重寫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;
        // 如果參數為空，或者類型信息不一樣，則認為不同
        if (o == null || getClass() != o.getClass())
            return false;
        // 轉換為當前類型
        Person person = (Person) o;
        // 要求基本類型相等，并且將引用類型交給java.util.Objects類的equals靜態方法取用結果
        return age == person.age && Objects.equals(name, person.name);
    }
}

這段代碼充分考慮了對象為空、類型一致等問題，但方法內容并不唯一。大多數IDE都可以自動生成equals方法的代碼內容。在IntelliJ IDEA中，可以使用Code菜單中的Generate…選項，也可以使用快捷鍵alt+insert，并選擇equals() and hashCode()進行自動代碼生成。如下圖所示：

tips：Object類當中的hashCode等其他方法，今后學習。

在剛才IDEA自動重寫equals代碼中，使用到了java.util.Objects類，那么這個類是什么呢？

在JDK7添加了一個Objects工具類，它提供了一些方法來操作對象，它由一些靜態的實用方法組成，這些方法是null-save（空指針安全的）或null-tolerant（容忍空指針的），用于計算對象的hashcode、返回對象的字符串表示形式、比較兩個對象。

在比較兩個對象的時候，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));  
}

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秒。

簡單來說：使用無參構造，可以自動設置當前系統時間的毫秒時刻；指定long類型的構造參數，可以自定義毫秒時刻。例如：

import java.util.Date;

public class Demo01Date {
    public static void main(String[] args) {
        // 創建日期對象，把當前的時間
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
        // 創建日期對象，把當前的毫秒值轉成日期對象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}

tips:在使用println方法時，會自動調用Date類中的toString方法。Date類對Object類中的toString方法進行了覆蓋重寫，所以結果為指定格式的字符串。

Date類中的多數方法已經過時，常用的方法有：

public long getTime() 把日期對象轉換成對應的時間毫秒值。

java.text.DateFormat 是日期/時間格式化子類的抽象類，我們通過這個類可以幫我們完成日期和文本之間的轉換,也就是可以在Date對象與String對象之間進行來回轉換。

格式化：按照指定的格式，從Date對象轉換為String對象。

解析：按照指定的格式，從String對象轉換為Date對象。

由于DateFormat為抽象類，不能直接使用，所以需要常用的子類java.text.SimpleDateFormat。這個類需要一個模式（格式）來指定格式化或解析的標準。構造方法為：

public SimpleDateFormat(String pattern)：用給定的模式和默認語言環境的日期格式符號構造SimpleDateFormat。

參數pattern是一個字符串，代表日期時間的自定義格式。

常用的格式規則為：

備注：更詳細的格式規則，可以參考SimpleDateFormat類的API文檔0。

創建SimpleDateFormat對象的代碼如：

import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class Demo02SimpleDateFormat {
    public static void main(String[] args) {
        // 對應的日期格式如：2018-01-16 15:06:38
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }    
}

DateFormat類的常用方法有：

public String format(Date date)：將Date對象格式化為字符串。

public Date parse(String source)：將字符串解析為Date對象。

使用format方法的代碼為：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date對象轉換成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 創建日期格式化對象,在獲取格式化對象時可以指定風格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

使用parse方法的代碼為：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;  
/*
 把String轉換成Date對象
*/
public class Demo04DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = "2018年12月11日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
    }
}

請使用日期時間相關的API，計算出一個人已經出生了多少天。

思路：

1.獲取當前時間對應的毫秒值

2.獲取自己出生日期對應的毫秒值

3.兩個時間相減（當前時間– 出生日期）

代碼實現：

public static void function() throws Exception {
    System.out.println("請輸入出生日期 格式 YYYY-MM-dd");
    // 獲取出生日期,鍵盤輸入
    String birthdayString = new Scanner(System.in).next();
    // 將字符串日期,轉成Date對象
    // 創建SimpleDateFormat對象,寫日期模式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    // 調用方法parse,字符串轉成日期對象
    Date birthdayDate = sdf.parse(birthdayString);    
    // 獲取今天的日期對象
    Date todayDate = new Date();    
    // 將兩個日期轉成毫秒值,Date類的方法getTime
    long birthdaySecond = birthdayDate.getTime();
    long todaySecond = todayDate.getTime();
    long secone = todaySecond-birthdaySecond;    
    if (secone < 0){
        System.out.println("還沒出生呢");
    } else {
        System.out.println(secone/1000/60/60/24);
    }
}

日歷我們都見過

java.util.Calendar是日歷類，在Date后出現，替換掉了許多Date的方法。該類將所有可能用到的時間信息封裝為靜態成員變量，方便獲取。日歷類就是方便獲取各個時間屬性的。

Calendar為抽象類，由于語言敏感性，Calendar類在創建對象時并非直接創建，而是通過靜態方法創建，返回子類對象，如下：

Calendar靜態方法

public static Calendar getInstance()：使用默認時區和語言環境獲得一個日歷

例如：

import java.util.Calendar;

public class Demo06CalendarInit {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
    }    
}

根據Calendar類的API文檔，常用方法有：

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對象。

Calendar類中提供很多成員常量，代表給定的日歷字段：

get方法用來獲取指定字段的值，set方法用來設置指定字段的值，代碼使用演示：

import java.util.Calendar;

public class CalendarUtil {
    public static void main(String[] args) {
        // 創建Calendar對象
        Calendar cal = Calendar.getInstance();
        // 設置年 
        int year = cal.get(Calendar.YEAR);
        // 設置月
        int month = cal.get(Calendar.MONTH) + 1;
        // 設置日
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
    }    
}

import java.util.Calendar;

public class Demo07CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2020);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2020年1月17日
    }
}

add方法可以對指定日歷字段的值進行加減操作，如果第二個參數為正數則加上偏移量，如果為負數則減去偏移量。代碼如：

import java.util.Calendar;

public class Demo08CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日
        // 使用add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 減3年
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日; 
    }
}

Calendar中的getTime方法并不是獲取毫秒時刻，而是拿到對應的Date對象。

import java.util.Calendar;
import java.util.Date;

public class Demo09CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();
        System.out.println(date); // Tue Jan 16 16:03:09 CST 2018
    }
}

小貼士：
?     西方星期的開始為周日，中國為周一。
?     在Calendar類中，月份的表示是以0-11代表1-12月。
?     日期是有大小關系的，時間靠后，時間越大。

java.lang.System類中提供了大量的靜態方法，可以獲取與系統相關的信息或系統級操作，在System類的API文檔中，常用的方法有：

public static long currentTimeMillis()：返回以毫秒為單位的當前時間。

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：將數組中指定的數據拷貝到另一個數組中。

實際上，currentTimeMillis方法就是 獲取當前系統時間與1970年01月01日00:00點之間的毫秒差值

import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) {
           //獲取當前時間毫秒值
        System.out.println(System.currentTimeMillis()); // 1516090531144
    }
}

驗證for循環打印數字1-9999所需要使用的時間（毫秒）

public class SystemTest1 {
    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個參數，含義分別為：

將src數組中前3個元素，復制到dest數組的前3個位置上復制元素前：src數組元素[1,2,3,4,5]，dest數組元素[6,7,8,9,10]復制元素后：src數組元素[1,2,3,4,5]，dest數組元素[1,2,3,9,10]

import java.util.Arrays;

public class Demo11SystemArrayCopy {
    public static void main(String[] args) {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);
        /*代碼運行后：兩個數組中的元素發生了變化
         src數組元素[1,2,3,4,5]
         dest數組元素[1,2,3,9,10]
        */
    }
}

由于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 。

由此可知，如果對字符串進行拼接操作，每次拼接，都會構建一個新的String對象，既耗時，又浪費空間。為了解決這一問題，可以使用java.lang.StringBuilder類。

查閱java.lang.StringBuilder的API，StringBuilder又稱為可變字符序列，它是一個類似于 String 的字符串緩沖區，通過某些方法調用可以改變該序列的長度和內容。

原來StringBuilder是個字符串的緩沖區，即它是一個容器，容器中可以裝很多字符串。并且能夠對其中的字符串進行各種操作。

它的內部擁有一個數組用來存放字符串內容，進行字符串拼接時，直接在數組中加入新內容。StringBuilder會自動維護數組的擴容。原理如下圖所示：(默認16字符空間，超過自動擴充)

根據StringBuilder的API文檔，常用構造方法有2個：

public StringBuilder()：構造一個空的StringBuilder容器。

public StringBuilder(String str)：構造一個StringBuilder容器，并將字符串添加進去。

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); // (空白)
        // 使用帶參構造
        StringBuilder sb2 = new StringBuilder("itcast");
        System.out.println(sb2); // itcast
    }
}

StringBuilder常用的方法有2個：

public StringBuilder append(...)：添加任意類型數據的字符串形式，并返回當前對象自身。

public String toString()：將當前StringBuilder對象轉換為String對象。

append方法具有多種重載形式，可以接收任意類型的參數。任何數據作為參數都會將對應的字符串內容添加到StringBuilder中。例如：

public class Demo02StringBuilder {
    public static void main(String[] args) {
        //創建對象
        StringBuilder builder = new StringBuilder();
        //public StringBuilder append(任意類型)
        StringBuilder builder2 = builder.append("hello");
        //對比一下
        System.out.println("builder:"+builder);
        System.out.println("builder2:"+builder2);
        System.out.println(builder == builder2); //true
        // 可以添加 任何類型
        builder.append("hello");
        builder.append("world");
        builder.append(true);
        builder.append(100);
        // 在我們開發中，會遇到調用一個方法后，返回一個對象的情況。然后使用返回的對象繼續調用方法。
        // 這種時候，我們就可以把代碼現在一起，如append方法一樣，代碼如下
        //鏈式編程
        builder.append("hello").append("world").append(true).append(100);
        System.out.println("builder:"+builder);
    }
}

備注：StringBuilder已經覆蓋重寫了Object當中的toString方法。

通過toString方法，StringBuilder對象將會轉換為不可變的String對象。如：

public class Demo16StringBuilder {
    public static void main(String[] args) {
        // 鏈式創建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 調用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }
}

Java提供了兩個類型系統，基本類型與引用類型，使用基本類型在于效率，然而很多情況，會創建對象使用，因為對象可以做更多的功能，如果想要我們的基本類型像對象一樣操作，就可以使用基本類型對應的包裝類，如下：

基本類型與對應的包裝類對象之間，來回轉換的過程稱為”裝箱“與”拆箱“：

裝箱：從基本類型轉換為對應的包裝類對象。

拆箱：從包裝類對象轉換為對應的基本類型。

用Integer與 int為例：（看懂代碼即可）

基本數值---->包裝對象

Integer i = new Integer(4);//使用構造函數函數
Integer iii = Integer.valueOf(4);//使用包裝類中的valueOf方法

包裝對象---->基本數值

int num = i.intValue();

由于我們經常要做基本類型與包裝類之間的轉換，從Java 5（JDK 1.5）開始，基本類型與包裝類的裝箱、拆箱動作可以自動完成。例如：

Integer i = 4;//自動裝箱。相當于Integer i = Integer.valueOf(4);
i = i + 5;//等號右邊：將i對象轉成基本數值(自動拆箱) i.intValue() + 5;
//加法運算完成后，再次裝箱，把基本數值轉成對象。

基本類型轉換String總共有三種方式，查看課后資料可以得知，這里只講最簡單的一種方式：

基本類型直接與””相連接即可；如：34+""

String轉換成對應的基本類型
int m = 9;
System.out.println(9+"");

//2 包裝類的靜態方法
String s2 = Integer.toString(23);
System.out.println(s2);

//3 String類的靜態方法 valueOf
int s3 = 45;
String s4 = String.valueOf(s3);
System.out.println(s4);

除了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類的靜態方法parseXxx為例）如：

public class Demo18WrapperParse {
    public static void main(String[] args) {
        int num = Integer.parseInt("100");
    }
}

注意:如果字符串參數的內容無法正確轉換為對應的基本類型，則會拋出java.lang.NumberFormatException異常。