Java語言的Object類和常用的API

Java進階

Object類
日期時間類
System類
StringBuilder類
包裝類

Object類

1、概述：java.lang.Object`類是Java語言中的根類，即所有類的父類別。（如果一個類沒有特別指定父類別，那麼預設則繼承自Object類。）

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

2、toString方法：public String toString()`：返回該物件的字串表示。
（1）toString方法的覆蓋重寫：如果不希望使用toString方法的預設行爲，則可以對它進行覆蓋重寫。
小貼士：在我們直接使用輸出語句輸出物件名的時候,其實通過該物件呼叫了其toString()方法。

public class Demo01ToString {
    public static void main(String[] args) {
        /*
        Person類預設繼承了Object類，所以可以使用Object類中的toString方法
        String toString() 返回該物件的字串表示。
        * */
        Person p =new Person("William",18);
        String s =p.toString();
        System.out.println(s); //medo01.Person@be631310

        //直接列印物件的名字，其實就是呼叫物件的 roString p =p.toString();
        System.out.println(p);
        //看一個類是否重寫了toString，直接列印這個類的物件即可，如果沒有重寫tooString方法那麼列印的是物件的地址值
        Random r = new Random();
        System.out.println(r); //java.util.Random@282ba1e沒有重寫toString方法

        Scanner sc = new Scanner(System.in);
        System.out.println(sc); //java.util.Scanner[delimiters=\p{javaWhitespace}+..重寫toString方法

        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list); //[1, 2, 3]重寫toString方法
    }
}

import java.util.Objects;

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

    public Person() {
    }

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

    /*
      直接列印物件的地址值沒有意義,需要重寫Object類中的toString方法
      列印物件的屬性(name,age)
   */
   /* @Override
    public String toString() {
      //  return "abc";
        return "Person{name"+name+",age="+age+"}";
    } */
   /*@Override
   public String toString() {
       return "Person{" +
               "name='" + name +'\'' +
               ", age=" + age +
                '}';
   }*/
   /* Object類的equals方法，預設比較的是兩個物件的地址值，沒有意義，
      所以我們要重寫equals方法，比較兩個物件的屬性(name,age)
      問題：
      隱含着一個多型
      多型的弊端：無法使用子類特有的內容（屬性和方法）
      Object obj = p2 = new Person("古力娜扎",19);
   * */
   /*@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;
   }*/
    @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);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, 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;
    }
}

3、equals方法：public boolean equals(Object obj)`：指示其他某個物件是否與此物件「相等」。
呼叫成員方法equals並指定參數爲另一個物件，則可以判斷這兩個物件是否是相同的。這裏的「相同」有預設和自定義兩種方式。

1）預設地址比較：如果沒有覆蓋重寫equals方法，那麼Object類中預設進行==運算子的物件地址比較，只要不是同一個物件，結果必然爲false。
2）物件內容比較：如果希望進行物件的內容比較，即所有或指定的部分成員變數相同就判定兩個物件相同，則可以覆蓋重寫equals方法。

import java.util.ArrayList;

public class Demo02Equals {
    public static void main(String[] args) {
        /*
         Person類預設繼承了Object類,所以可以使用Object類的equals方法
            boolean equals(Object obj) 指示其他某個物件是否與此物件「相等」。
            equals方法原始碼:
                public boolean equals(Object obj) {
                    return (this == obj);
                }
                參數:
                    Object obj:可以傳遞任意的物件
                    == 比較運算子,返回的是一個布爾值 true false
                    基本數據型別:比較的是值
                    參照數據型別:比較的是兩個物件的地址值
               this是誰?那個物件呼叫的方法,方法中的this就是那個物件;p1呼叫的equals方法所以this就是p1
               obj是誰?傳遞過來的參數p2
               this==obj -->p1==p2
        * */
        Person p1 = new Person("John",18);
        //Person p2 = new Person("Kitty",19);
        Person p2 = new Person("Alan",18);
        System.out.println("p1"+p1); //p1medo01.Person@446d808
        System.out.println("p2"+p2); //p2medo01.Person@3c68d1b

        //p1 = p2;//把p2的地址值賦值給p1
        ArrayList<String> list = new ArrayList<>();
        boolean b =p1.equals(p1);
        System.out.println(b); //true

    }
}

4、Objects類：在JDK7新增了一個Objects工具類，它提供了一些方法來操作物件，它由一些靜態的實用方法組成，這些方法是null-save（空指針安全的）或null-tolerant（容忍空指針的），用於計算物件的hashcode、返回物件的字串表示形式、比較兩個物件。
在比較兩個物件的時候，Object的equals方法容易拋出空指針異常，而Objects類中的equals方法就優化了這個問題。

import java.io.PushbackInputStream;
import java.util.Objects;

public class Demo03Objects {
    public static void main(String[] args) {
        String s1 ="abc";
        //String s1 = null;
        String s2 = "abc";
      //  boolean b = s1.equals(s2); //NullPointerException null 是不能呼叫方法的，會拋出空指針異常
       // System.out.println(b);
        /*
        Objects類的equals方法：對連個現象進行比較，防止空指針異常
        public static boolean equals(Object a,Object b) {
            return (a == b) ||(a! =null && a.equals(b));
        }
        */
        boolean b2 = Objects.equals(s1, s1);
        System.out.println(b2);

    }
}

日期時間類

1、Date類：java.util.Date:表示日期和時間的類。（類 Date 表示特定的瞬間，精確到毫秒。）
注：
1）毫秒:千分之一秒 1000毫秒=1秒
2）特定的瞬間:一個時間點,一剎那時間
3）毫秒值的作用:可以對時間和日期進行計算。

例：把日期轉換爲毫秒:
當前的日期:2020-08-11；時間原點(0毫秒):1970 年 1 月 1 日 00:00:00(英國格林威治)
就是計算當前日期到時間原點之間一共經歷了多少毫秒。
注意:
中國屬於東八區,會把時間增加8個小時
1970 年 1 月 1 日 08:00:00
把毫秒轉換爲日期的公式:
1 天 = 24 × 60 × 60 = 86400 秒 = 86400 x 1000 = 86400000毫秒

public class Demo01Date {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis()); //獲取當前系統時間到1970年1月1日00：00：00經歷了多少毫秒
    }
}

tips:在使用println方法時，會自動呼叫Date類中的toString方法。Date類對Object類中的toString方法進行了覆蓋重寫，所以結果爲指定格式的字串。
常用方法：Date類中的多數方法已經過時，常用的方法有：
public long getTime() 把日期物件轉換成對應的時間毫秒值。

import java.util.Date;

public class Demo02Date {
    public static void main(String[] args) {

        demo03();
    }

         /*
           long getTime() 把日期轉換爲毫秒值(相當於System.currentTimeMillis()方法)
             返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 物件表示的毫秒數。
        */
    private static void demo03() {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time); //1596940639073
    }

    /*
        Date類的帶參數構造方法
        Date(long date) :傳遞毫秒值,把毫秒值轉換爲Date日期
     */
    private static void demo02() {
        Date date = new Date(0L);
        System.out.println(date);//Thu Jan 01 08:00:00 CST 1970
    }


    /*
    Date類的空參數構造方法
    Date()獲取當前系統的日期和時間
    * */
    private static void demo01() {
        Date date = new Date();
        System.out.println(date); //Sun Aug 09 01:03:27 CST 2020
    }
}

2、DateFormat類：java.text.DateFormat` 是日期/時間格式化子類的抽象類。
1）作用: 格式化（也就是日期 -> 文字）、解析（文字-> 日期）
2）成員方法:

String format(Date date) 按照指定的模式,把Date日期,格式化爲符合模式的字串。
Date parse(String source) 把符合模式的字串,解析爲Date日期。
DateFormat類是一個抽象類,無法直接建立物件使用,可以使用DateFormat類的子類。
java.text.SimpleDateFormat extends DateFormat
3）構造方法:
SimpleDateFormat(String pattern)
用給定的模式和預設語言環境的日期格式符號構造 SimpleDateFormat。
參數:
String pattern:傳遞指定的模式
模式:區分大小寫的

符號	意思
y	年
M	月
d	日
H	時
m	分
s	秒

寫對應的模式,會把模式替換爲對應的日期和時間「yyyy-MM-dd HH:mm:ss」
注意:
模式中的字母不能更改,連線模式的符號可以改變
「yyyy年MM月dd日 HH時mm分ss秒」

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

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

    /*
        使用DateFormat類中的方法parse,把文字解析爲日期
        使用步驟:
           1.建立SimpleDateFormat物件,構造方法中傳遞指定的模式
           2.呼叫SimpleDateFormat物件中的方法parse,把符合構造方法中模式的字串,解析爲Date日期
           注意:
               public Date parse(String source) throws ParseException
               parse方法宣告瞭一個異常叫ParseException
               如果字串和構造方法的模式不一樣,那麼程式就會拋出此異常
               呼叫一個拋出了異常的方法,就必須的處理這個異常,要麼throws繼續拋出這個異常,要麼try catch自己處理
    */
    private static void demo02() throws ParseException
    {
        //1.建立SimpleDateFormat物件,構造方法中傳遞指定的模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyy年MM月dd日 HH時mm分ss秒");
        //2.呼叫SimpleDateFormat物件中的方法parse,把符合構造方法中模式的字串,解析爲Date日期
        //Date parse(String source)  把符合模式的字串,解析爲Date日期
        Date date = sdf.parse("2020年08月09日 11時00分00秒");
        System.out.println(date); //Sun Aug 09 11:00:00 CST 2020
    }

    /*
      使用DateFormat類中的方法format,把日期格式化爲文字
      使用步驟:
          1.建立SimpleDateFormat物件,構造方法中傳遞指定的模式
          2.呼叫SimpleDateFormat物件中的方法format,按照構造方法中指定的模式,把Date日期格式化爲符合模式的字串(文字)
   */
    private static void demo01() {
        //1.建立SimpleDateFormat物件，構造方法中傳遞指定的模式
        SimpleDateFormat sdf =new SimpleDateFormat("yyy年MM月dd日 HH時mm分ss秒");
        //2.呼叫SimpleDateFormat物件中的方法format，按照構造方法中指定的模式，把Date日期格式化爲符合模式的字串（文字）
        //String format(Date date) 按照指定的模式，把Date日期，格式化爲符合模式的字串
        Date date = new Date();
        String d = sdf.format(date);
        System.out.println(date); //Sun Aug 09 10:56:14 CST 2020
        System.out.println(d); //2020年08月09日 10時56分14秒
    }
}

3、練習：
題目： 計算出一個人已經出生了多少天。
分析:
1.使用Scanner類中的方法next,獲取出生日期
2.使用DateFormat類中的方法parse,把字串的出生日期,解析爲Date格式的出生日期
3.把Date格式的出生日期轉換爲毫秒值
4.獲取當前的日期,轉換爲毫秒值
5.使用當前日期的毫秒值-出生日期的毫秒值
6.把毫秒差值轉換爲天(s/1000/60/60/24)
import java.text.ParseException;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Demo02Test {
    public static void main(String[] args) throws ParseException {
        //1.使用Scanner類中的方法next，獲取出生日期
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入您的出生日期，格式爲：yyyy-MM-dd");
        String birthdayDateString = sc.next();
        //2.使用DateFormat類中的方法parse，把字串的出生日期解析爲Date格式的 出生日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");
        Date birthdayDate = sdf.parse(birthdayDateString);
        //3.把Date格式的出生日期轉換爲毫秒值
        long birthdayDateTime = birthdayDate.getTime();
        //4.獲取當前的日期，轉換爲毫秒值
        long todayTime = new Date().getTime();
        //5.使用當前日期的毫秒值-出生日期的毫秒值
        long time = todayTime-birthdayDateTime;
        //6.把毫秒值轉換爲天（s/1000/60/60/24）
        System.out.println(time/1000/60/60/24);
    }

4、Calendar類：
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);
    }
}

2） 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物件。（Calendar中的getTime方法並不是獲取毫秒時刻，而是拿到對應的Date物件。）
3）成員方法的參數:
int field:日曆類的欄位,可以使用Calendar類的靜態成員變數獲取
Calendar類中提供很多成員常數，代表給定的日曆欄位：

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

小貼士：

西方星期的開始爲週日，中國爲週一。
在Calendar類中，月份的表示是以0-11代表1-12月。
日期是有大小關係的，時間靠後，時間越大。

import java.time.Year;
import java.util.Calendar;
import java.util.concurrent.Callable;
public class Demo02Calendar {
    public static void main(String[] args) {
        demo01();
    }

    /*
        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+1); //西方的月份：0-11，東方：1-12
        //int date = c.get(Calendar.DAY_OF_MONTH);
        int date = c.get(Calendar.DATE);
        System.out.println(date);
    }
}

System類

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

public static long currentTimeMillis()：返回以毫秒爲單位的當前時間。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：將陣列中指定的數據拷貝到另一個數組中。
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]
```

import java.lang.reflect.Array;
import java.util.Arrays;

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

    }

private static void demo02() {
        //定義原陣列
        int[] src = {1,2,3,4,5};
        //定義目標陣列
        int[] dest = {5,4,3,2,1};
        System.out.println("複製前："+ Arrays.toString(dest));//複製前：[5, 4, 3, 2, 1]
        //使用System類中的arraycopy把原陣列的前三個元素複製到目標陣列的前三個位置上
        System.arraycopy(src,0,dest,0,3);
        System.out.println("複製後:"+Arrays.toString(dest)); //複製後:[1, 2, 3, 2, 1]
    }

    /*
           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)+"毫秒"); //程式耗時94毫秒
    }*/
}

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

StringBuilder類

1、概述：在这里插入图片描述 java.lang.StringBuilder類:字串緩衝區,可以提高字串的效率
2、構造方法:
1.StringBuilder() 構造一個不帶任何字元的字串生成器，其初始容量爲 16 個字元。
2. StringBuilder(String str) 構造一個字串生成器，並初始化爲指定的字串內容。

public class Demo01StringBuilder {
    public static void main(String[] args) {
        //空參數構造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);

        //帶字串的構造方法
        StringBuilder bu2 = new StringBuilder("cde");
        System.out.println("bu2:"+bu2);
    }
}

3、常用方法：

public StringBuilder append(…)：新增任意型別數據的字串形式，並返回當前物件自身。
public String toString()`：將當前StringBuilder物件轉換爲String物件。

1）append方法：
append方法具有多種過載形式，可以接收任意型別的參數。任何數據作爲參數都會將對應的字串內容新增到StringBuilder中。

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(2);
//        bu.append(true);
//        bu.append(6.6);
//        bu.append('中');
//        System.out.println(bu); //abc2true6.6中

         /*
            鏈式程式設計:方法返回值是一個物件,可以繼續呼叫方法
         */
        System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase());
        bu.append("abc").append(2).append(true).append(6.6).append('中');
        System.out.println(bu); //abc2true6.6中
    }
}

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

3） 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);
    }
}

包裝類

1、概述：Java提供了兩個型別系統，基本型別與參照型別，使用基本型別在於效率，然而很多情況，會建立物件使用，因爲物件可以做更多的功能，如果想要我們的基本型別像物件一樣操作，就可以使用基本型別對應的包裝類。

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

在这里插入图片描述
2、裝箱和拆箱：
基本型別與對應的包裝類物件之間，來回轉換的過程稱爲」裝箱「與」拆箱「。
裝箱:把基本型別的數據,包裝到包裝類中(基本型別的數據->包裝類)。

構造方法:

Integer(int value) 構造一個新分配的 Integer 物件，它表示指定的 int 值。
Integer(String s) 構造一個新分配的 Integer 物件，它表示 String 參數所指示的 int 值。
傳遞的字串,必須是基本型別的字串,否則會拋出異常「100」正確「a」拋異常

靜態方法:
3. static Integer valueOf(int i) 返回一個表示指定的 int 值的 Integer 範例。
4. static Integer valueOf(String s) 返回儲存指定的 String 的值的 Integer 物件。

拆箱:在包裝類中取出基本型別的數據(包裝類->基本型別的數據)

成員方法:
int intValue() 以 int 型別返回該 Integer 的值。

 public class Demo01Integer {
    public static void main(String[] args) {
        //裝箱:把基本型別的數據,包裝到包裝類中(基本型別的數據->包裝類)
        //構造方法
        Integer in1 = new Integer(1); //方法上有橫線則說明方法過時了
        System.out.println(in1); //重寫；阿toString方法

        Integer in2 = new Integer("1");
        System.out.println(in2);

        //靜態方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3);

        //Integer in4 = Integer.valueOf("a"); //NumberFormatException數位格式化異常
        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);

        //拆箱:在包裝類中取出基本型別的數據(包裝類->基本型別的數據)
        int i = in1.intValue();
        System.out.println(i);
    }
}

3、自動裝箱與自動拆箱:基本型別的數據和包裝類之間可以自動的相互轉換
JDK1.5之後出現的新特性

import java.util.ArrayList;

  public class Demo02Integer {
    public static void main(String[] args) {
        /*
            自動裝箱:直接把int型別的整數賦值包裝類
            Integer in = 1; 就相當於 Integer in = new Integer(1);
         */
        Integer in = 1;

       /*
            自動拆箱:in是包裝類,無法直接參與運算,可以自動轉換爲基本數據型別,在進行計算
            in+2;就相當於 in.intVale() + 2 = 3
            in = in.intVale() + 2 = 3 又是一個自動裝箱
         */
       in = in + 2;
        ArrayList<Integer> list = new ArrayList<>();
         /*
            ArrayList集合無法直接儲存整數,可以儲存Integer包裝類
         */
         list.add(1); //-->自動裝箱 list.add(new Integer(1));
        int a =list.get(0); //-->自動拆箱  list.get(0).intValue();
    }
}

4、基本型別與字串型別之間的相互轉換：

1）基本型別->字串(String)
1.基本型別的值+"" 最簡單的方法(工作中常用)
2.包裝類的靜態方法toString(參數),不是Object類的toString() 過載
static String toString(int i) 返回一個表示指定整數的 String 物件。
3.String類的靜態方法valueOf(參數)
static String valueOf(int i) 返回 int 參數的字串表示形式。

2）字串(String)->基本型別
使用包裝類的靜態方法parseXXX(「字串」);

Integer類: static int parseInt(String s)
Double類: static double parseDouble(String s)

public class Demo03Integer {
    public static void main(String[] args) {
        //基本型別-》字串(String)
        int i1 = 100;
        String s1 =  i1 +"";
        System.out.println(s1+222); //100222

        String s2 =Integer.toString(100);
        System.out.println(s2+222); //100222

        String s3 = String.valueOf(100);
        System.out.println(s2+222); //100222

        //字串(String)->基本型別
        int a = Integer.parseInt("a"); ////NumberFormatException
        System.out.println(a);
    }
}

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異常。