day01【Object類、常用API】

主要内容

• Object類
• Date類
• DateFormat類
• Calendar類
• System類
• StringBuilder類
• 包裝類

教學目标

-[ ] 能夠說出Object類的特點

-[ ] 能夠重寫Object類的toString方法

-[ ] 能夠重寫Object類的equals方法

-[ ] 能夠使用日期類輸出目前日期

-[ ] 能夠使用将日期格式化為字元串的方法

-[ ] 能夠使用将字元串轉換成日期的方法

-[ ] 能夠使用System類的數組複制方法

-[ ] 能夠使用System類擷取目前毫秒時刻值

-[ ] 能夠說出使用StringBuilder類可以解決的問題

-[ ] 能夠使用StringBuilder進行字元串拼接操作

-[ ] 能夠說出8種基本類型對應的包裝類名稱

-[ ] 能夠說出自動裝箱、自動拆箱的概念

-[ ] 能夠将字元串轉換為對應的基本類型

-[ ] 能夠将基本類型轉換為對應的字元串

第一章 Object類

1.1 概述

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)

  ：訓示其他某個對象是否與此對象“相等”。

1.2 toString方法

方法摘要

• public String toString()

  ：傳回該對象的字元串表示。

toString方法傳回該對象的字元串表示，其實該字元串内容就是對象的類型[email protected]+記憶體位址值。

由于toString方法傳回的結果是記憶體位址，而在開發中，經常需要按照對象的屬性得到相應的字元串表現形式，是以也需要重寫它。

覆寫重寫

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

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

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

    // 省略構造器與Getter Setter
}


/*直接列印對象對象的位址值沒有意義，需要重寫Object類的toString方法
    列印對象的屬性{name,age}
    * */


    /*   //重寫方法1
    public String toString(){
        return "Person{name="+name+",age= "+age+"}";
    }
    */

    /*//方法2 Alt+Insert-->toString-->選擇全部
    *     @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    * */

    /*
    * 看一個類是否重寫了toString方法，直接列印這個類對應的名字即可
    * 如果沒有重寫toStirng方法，那麼列印的就是對象的位址值（預設）
    * 如果重寫了toString方法,那麼久按照重寫的方式列印
    * */

           

在IntelliJ IDEA中，可以點選

Code

菜單中的

Generate...

，也可以使用快捷鍵

alt+insert

，點選

toString()

選項。選擇需要包含的成員變量并确定。如下圖所示：

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-o4FoCmh9-1611988910483)(img\toString方法的自動重寫.bmp)]

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

1.3 equals方法

方法摘要

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



 預設位址比較

如果沒有覆寫重寫equals方法，那麼Object類中預設進行`==`運算符的對象位址比較，隻要不是同一個對象，結果必然為false。

對象内容比較

如果希望進行對象的内容比較，即所有或指定的部分成員變量相同就判定兩個對象相同，則可以覆寫重寫equals方法。

equals方法預設比較的位址值比較，隻要不是同一個對象，結果必然是false。現在隻想要比較内容，而不比較位址值
 是以需要重寫equals方法
     
     
     
       /*
        Object類的equals方法,預設比較的是兩個對象的位址值,沒有意義
        是以我們要重寫equals方法,比較兩個對象的屬性(name,age)
        問題:
            隐含着一個多态
            多态的弊端:無法使用子類特有的内容(屬性和方法)
            Object obj = p2 = new Person("古力娜紮",19);
            解決:可以使用向下轉型(強轉)把obj類型轉換為Person
     */
    /*@Override
    public boolean equals(Object obj) {
        //增加一個判斷,傳遞的參數obj如果是this本身,直接傳回true,提高程式的效率
        if(obj==this){
            return true;
        }

        //增加一個判斷,傳遞的參數obj如果是null,直接傳回false,提高程式的效率
        if(obj==null){
            return false;
        }

        //增加一個判斷,防止類型轉換一次ClassCastException
        if(obj instanceof Person){
            //使用向下轉型,把obj轉換為Person類型
            Person p = (Person)obj;
            //比較兩個對象的屬性,一個對象是this(p1),一個對象是p(obj->p2)
            boolean b = this.name.equals(p.name) && this.age==p.age;
            return b;
        }
        //不是Person類型直接傳回false
        return false;
    }*/  
           

這段代碼充分考慮了對象為空、類型一緻等問題，但方法内容并不唯一。大多數IDE都可以自動生成equals方法的代碼内容。在IntelliJ IDEA中，可以使用

Code

菜單中的

Generate…

選項，也可以使用快捷鍵

alt+insert

，并選擇

equals() and hashCode()

進行自動代碼生成。如下圖所示：

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-UNUYZYHY-1611988910485)(img\equals方法1.png)]

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-AQO62uve-1611988910487)(img\equals方法2.png)]

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-GEaWNbgm-1611988910488)(img\equals方法3.png)]

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

1.4 Objects類

在剛才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));  
}

在比較兩個對象的時候，Object的equals方法容易抛出空指針異常，而Objects類中的equals方法就優化了這個問題
主要是在Objects類中可以容忍空指針
在**JDK7**添加了一個Objects工具類，它提供了一些方法來操作對象，它由一些靜态的實用方法組成，這些方法是null-save（空指針安全的）或null-tolerant（容忍空指針的），用于計算對象的hashcode、傳回對象的字元串表示形式、比較兩個對象。
           

第二章 日期時間類

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

簡單來說：使用無參構造，可以自動設定目前系統時間的毫秒時刻；指定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()

  把日期對象轉換成對應的時間毫秒值。

2.2 DateFormat類

java.text.DateFormat

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

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

構造方法

由于DateFormat為抽象類，不能直接使用，是以需要常用的子類

java.text.SimpleDateFormat

。這個類需要一個模式（格式）來指定格式化或解析的标準。構造方法為：

• public SimpleDateFormat(String pattern)

  ：用給定的模式和預設語言環境的日期格式符号構造SimpleDateFormat。

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

格式規則

常用的格式規則為：

辨別字母（區分大小寫）	含義
y	年
M	月
d	日
H	時
m	分
s	秒

備注：更詳細的格式規則，可以參考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");
    }    
}

*
    java.text.DateFormat:是日期/時間格式化子類的抽象類
    作用:
        格式化（也就是日期 -> 文本）、解析（文本-> 日期）
    成員方法:
        String format(Date date)  按照指定的模式,把Date日期,格式化為符合模式的字元串
        Date parse(String source)  把符合模式的字元串,解析為Date日期
    DateFormat類是一個抽象類,無法直接建立對象使用,可以使用DateFormat類的子類

    java.text.SimpleDateFormat extends DateFormat

    構造方法:
        SimpleDateFormat(String pattern)
          用給定的模式和預設語言環境的日期格式符号構造 SimpleDateFormat。
        參數:
             String pattern:傳遞指定的模式
        模式:區分大小寫的
            y   年
            M   月
            d   日
            H   時
            m   分
            s   秒
        寫對應的模式,會把模式替換為對應的日期和時間
            "yyyy-MM-dd HH:mm:ss"
        注意:
            模式中的字母不能更改,連接配接模式的符号可以改變
             "yyyy年MM月dd日 HH時mm分ss秒"

 */
           

常用方法

DateFormat類的常用方法有：

• public String format(Date date)

  ：将Date對象格式化為字元串。

• public Date parse(String source)

  ：将字元串解析為Date對象。

format方法

使用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方法

使用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
    }
}


 /*
         使用DateFormat類中的方法parse,把文本解析為日期
         使用步驟:
            1.建立SimpleDateFormat對象,構造方法中傳遞指定的模式
            2.調用SimpleDateFormat對象中的方法parse,把符合構造方法中模式的字元串,解析為Date日期
            注意:
                public Date parse(String source) throws ParseException
                parse方法聲明了一個異常叫ParseException
                如果字元串和構造方法的模式不一樣,那麼程式就會抛出此異常
                調用一個抛出了異常的方法,就必須的處理這個異常,要麼throws繼續抛出這個異常,要麼try catch自己處理
     */
           

2.3 練習

請使用日期時間相關的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);
	}
}
           

2.4 Calendar類

概念

月曆我們都見過

[外鍊圖檔轉存失敗,源站可能有防盜鍊機制,建議将圖檔儲存下來直接上傳(img-sFahJBMw-1611988910490)(img\月曆.jpg)]

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

/*
    java.util.Calendar類:月曆類
    Calendar類是一個抽象類,裡邊提供了很多操作月曆字段的方法(YEAR、MONTH、DAY_OF_MONTH、HOUR )
    Calendar類無法直接建立對象使用,裡邊有一個靜态方法叫getInstance(),該方法傳回了Calendar類的子類對象
    static Calendar getInstance() 使用預設時區和語言環境獲得一個月曆。
 */
public class Demo01Calendar {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();//多态
        System.out.println(c);//列印的不是對象的位址 重寫了toString方法
    }
}

           

常用方法

根據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類中提供很多成員常量，代表給定的月曆字段：

字段值	含義
YEAR	年
MONTH	月（從0開始，可以+1使用）
DAY_OF_MONTH	月中的天（幾号）
HOUR	時（12小時制）
HOUR_OF_DAY	時（24小時制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周幾，周日為1，可以-1使用）

get/set方法

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方法

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

getTime方法

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

           

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

/*
    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類的靜态成員變量擷取
            public static final int YEAR = 1;	年
            public static final int MONTH = 2;	月
            public static final int DATE = 5;	月中的某一天
            public static final int DAY_OF_MONTH = 5;月中的某一天
            public static final int HOUR = 10; 		時
            public static final int MINUTE = 12; 	分
            public static final int SECOND = 13;	秒
 */
public class Demo02Calendar {
    public static void main(String[] args) {
        demo04();
    }

    /*
        public Date getTime()：傳回一個表示此Calendar時間值（從曆元到現在的毫秒偏移量）的Date對象。
        把月曆對象,轉換為日期對象
     */
    private static void demo04() {
        //使用getInstance方法擷取Calendar對象
        Calendar c = Calendar.getInstance();

        Date date = c.getTime();
        System.out.println(date);
    }

    /*
        public abstract void add(int field, int amount)：根據月曆的規則，為給定的月曆字段添加或減去指定的時間量。
        把指定的字段增加/減少指定的值
        參數:
            int field:傳遞指定的月曆字段(YEAR,MONTH...)
            int amount:增加/減少指定的值
                正數:增加
                負數:減少
     */
    private static void demo03() {
        //使用getInstance方法擷取Calendar對象
        Calendar c = Calendar.getInstance();

        //把年增加2年
        c.add(Calendar.YEAR,2);
        //把月份減少3個月
        c.add(Calendar.MONTH,-3);


        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month);//西方的月份0-11 東方:1-12

        //int date = c.get(Calendar.DAY_OF_MONTH);
        int date = c.get(Calendar.DATE);
        System.out.println(date);
    }

    /*
        public void set(int field, int value)：将給定的月曆字段設定為給定值。
        參數:
            int field:傳遞指定的月曆字段(YEAR,MONTH...)
            int value:給指定字段設定的值
     */
    private static void demo02() {
        //使用getInstance方法擷取Calendar對象
        Calendar c = Calendar.getInstance();

        //設定年為9999
        c.set(Calendar.YEAR,9999);
        //設定月為9月
        c.set(Calendar.MONTH,9);
        //設定日9日
        c.set(Calendar.DATE,9);

        //同時設定年月日,可以使用set的重載方法
        c.set(8888,8,8);

        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month);//西方的月份0-11 東方:1-12

        int date = c.get(Calendar.DATE);
        System.out.println(date);
    }

    /*
        public int get(int field)：傳回給定月曆字段的值。
        參數:傳遞指定的月曆字段(YEAR,MONTH...)
        傳回值:月曆字段代表的具體的值
     */
    private static void demo01() {
        //使用getInstance方法擷取Calendar對象
        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int month = c.get(Calendar.MONTH);
        System.out.println(month);//西方的月份0-11 東方:1-12

        //int date = c.get(Calendar.DAY_OF_MONTH);
        int date = c.get(Calendar.DATE);
        System.out.println(date);
    }
}

           

小貼士：

​ 西方星期的開始為周日，中國為周一。

​ 在Calendar類中，月份的表示是以0-11代表1-12月。

​ 日期是有大小關系的，時間靠後，時間越大。

第三章 System類

java.lang.System

類中提供了大量的靜态方法，可以擷取與系統相關的資訊或系統級操作，在System類的API文檔中，常用的方法有：

• public static long currentTimeMillis()

  ：傳回以毫秒為機關的目前時間。

• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

  ：将數組中指定的資料拷貝到另一個數組中。

3.1 currentTimeMillis方法

實際上，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
    }
}






import java.util.Arrays;

/*
    java.lang.System類中提供了大量的靜态方法，可以擷取與系統相關的資訊或系統級操作，在System類的API文檔中，常用的方法有：
        public static long currentTimeMillis()：傳回以毫秒為機關的目前時間。
        public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将數組中指定的資料拷貝到另一個數組中。
 */
public class Demo01System {
    public static void main(String[] args) {
        demo02();
        StringBuilder sb = new StringBuilder();
    }

    /*
        public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将數組中指定的資料拷貝到另一個數組中。
        參數:
            src - 源數組。
            srcPos - 源數組中的起始位置(起始索引)。
            dest - 目标數組。
            destPos - 目标資料中的起始位置。
            length - 要複制的數組元素的數量。
        練習:
            将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]
     */
    private static void demo02() {
        //定義源數組
        int[] src = {1,2,3,4,5};
        //定義目标數組
        int[] dest = {6,7,8,9,10};
        System.out.println("複制前:"+ Arrays.toString(dest));
        //使用System類中的arraycopy把源數組的前3個元素複制到目标數組的前3個位置上
        System.arraycopy(src,0,dest,0,3);
        System.out.println("複制後:"+ Arrays.toString(dest));
    }
    
    

    /*
        public static long currentTimeMillis()：傳回以毫秒為機關的目前時間。
        用來程式的效率
        驗證for循環列印數字1-9999所需要使用的時間（毫秒）
     */
    private static void demo01() {
        //程式執行前,擷取一次毫秒值
        long s = System.currentTimeMillis();
        //執行for循環
        for (int i = 1; i <=9999 ; i++) {
            System.out.println(i);
        }
        //程式執行後,擷取一次毫秒值
        long e = System.currentTimeMillis();
        System.out.println("程式共耗時:"+(e-s)+"毫秒");//程式共耗時:106毫秒
    }
}

           

練習

驗證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));
    }
}
           

3.2 arraycopy方法

• 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	複制元素個數

練習

将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]
        */
    }
}
           

第四章 StringBuilder類

4.1 字元串拼接問題

由于String類的對象内容不可改變，是以每當進行字元串拼接時，總是會在記憶體中建立一個新的對象。例如：

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

String類：
	字元串是常量；他們的值在建立之後不能更改
    字元串的底層是一個被final修飾的數組，不能改變，是一個常量
    private final byte[] value;
	進行字元串的相加，記憶體中就會有多個字元串，占用空間，效率低下

StringBuder類；
        底層是緩沖區，可以提高字元串的操作效率（看作一個長度可以變化的字元串）
        底層也是一個數組，但是沒有被final修飾，長度可以改變
        byte[] value = new byte[16];
	StringBuder在記憶體中始終是一個數組，占用空間少，效率高 
        如果超出了StringBuder的容量，會自動擴容

           

在API中對String類有這樣的描述：字元串是常量，它們的值在建立後不能被更改。

根據這句話分析我們的代碼，其實總共産生了三個字元串，即

"Hello"

、

"World"

和

"HelloWorld"

。引用變量s首先指向

Hello

對象，最終指向拼接出來的新字元串對象，即

HelloWord

。

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

java.lang.StringBuilder

類。

4.2 StringBuilder概述

查閱

java.lang.StringBuilder

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

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

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

4.3 構造方法

根據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
    }
}


/*
    java.lang.StringBuilder類:字元串緩沖區,可以提高字元串的效率
    構造方法:
        StringBuilder() 構造一個不帶任何字元的字元串生成器，其初始容量為 16 個字元。
        StringBuilder(String str) 構造一個字元串生成器，并初始化為指定的字元串内容。
 */
public class Demo01StringBuilder {
    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
    }
}
           

4.4 常用方法

StringBuilder常用的方法有2個：

• public StringBuilder append(...)

  ：添加任意類型資料的字元串形式，并傳回目前對象自身。

• public String toString()

  ：将目前StringBuilder對象轉換為String對象。

append方法

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

建立對象的快捷鍵：
    例如建立：StringBuilder  bu = new StringBuilder();
	先寫 new StringBuilder() 然後 Alt+Enter 快捷鍵 選中
      就可以快速寫完 StringBuilder  bu = new 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);
	}
}



/*
    java.lang.StringBuilder類:字元串緩沖區,可以提高字元串的效率
    構造方法:
        StringBuilder() 構造一個不帶任何字元的字元串生成器，其初始容量為 16 個字元。
        StringBuilder(String str) 構造一個字元串生成器，并初始化為指定的字元串内容。
 */
public class Demo01StringBuilder {
    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的常用方法:
        public StringBuilder append(...)：添加任意類型資料的字元串形式，并傳回目前對象自身。
 */
public class Demo02StringBuilder {
    public static void main(String[] args) {
        //建立StringBuilder對象
        StringBuilder bu = new StringBuilder();
        //使用append方法往StringBuilder中添加資料
        //append方法傳回的是this,調用方法的對象bu,this==bu
        //StringBuilder bu2 = bu.append("abc");//把bu的位址指派給了bu2
        //System.out.println(bu);//"abc"
        //System.out.println(bu2);//"abc"
        //System.out.println(bu==bu2);//比較的是位址 true

        //使用append方法無需接收傳回值
//        bu.append("abc");
//        bu.append(1);
//        bu.append(true);
//        bu.append(8.8);
//        bu.append('中');
//        System.out.println(bu);//abc1true8.8中

        /*
            鍊式程式設計:方法傳回值是一個對象,可以繼續調用方法
         */
        System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase());
        bu.append("abc").append(1).append(true).append(8.8).append('中');
        System.out.println(bu);//abc1true8.8中

    }
}




           

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

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

*
    StringBuilder和String可以互相轉換:
        String->StringBuilder:可以使用StringBuilder的構造方法
            StringBuilder(String str) 構造一個字元串生成器，并初始化為指定的字元串内容。
        StringBuilder->String:可以使用StringBuilder中的toString方法
            public String toString()：将目前StringBuilder對象轉換為String對象。
 */
public class Demo03StringBuilder {
    public static void main(String[] args) {
        //String->StringBuilder
        String str = "hello";
        System.out.println("str:"+str);
        StringBuilder bu = new StringBuilder(str);
        //往StringBuilder中添加資料
        bu.append("world");
        System.out.println("bu:"+bu);

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

           

第五章 包裝類

5.1 概述

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

基本類型	對應的包裝類（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

5.2 裝箱與拆箱

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

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

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

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

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

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

5.3自動裝箱與自動拆箱

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

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

5.3 基本類型與字元串之間的轉換

基本類型轉換為String

基本類型轉換String總共有三種方式，檢視課後資料可以得知，這裡隻講最簡單的一種方式：

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

String轉換成對應的基本類型

除了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

異常。