13-StringBuffer類的概述/數組冒泡/二分查找/Arrays類/Integer類

13.01_常見對象(StringBuffer類的概述)

A:StringBuffer類概述
- 通過JDK提供的API，檢視StringBuffer類的說明
- 線程安全的可變字元序列
B:StringBuffer和String的差別
- String是一個不可變的字元序列
- StringBuffer是一個可變的字元序列

13.02_常見對象(StringBuffer類的構造方法)

A:StringBuffer的構造方法：
- public StringBuffer():無參構造方法
- public StringBuffer(int capacity):指定容量的字元串緩沖區對象
- public StringBuffer(String str):指定字元串内容的字元串緩沖區對象
B:StringBuffer的方法：
- public int capacity()：傳回目前容量。理論值(不掌握)
- public int length():傳回長度（字元數）。實際值
C:案例示範
- 構造方法和長度方法的使用

package com.heima.stringbuffer;

public class Demo1_StringBuffer {

    /**
     * * A:StringBuffer的構造方法：
            * public StringBuffer():無參構造方法
            * public StringBuffer(int capacity):指定容量的字元串緩沖區對象
            * public StringBuffer(String str):指定字元串内容的字元串緩沖區對象
        * B:StringBuffer的方法：
            * public int capacity()：傳回目前容量。 理論值(不掌握)
            * public int length():傳回長度（字元數）。 實際值
        * C:案例示範
            * 構造方法和長度方法的使用
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.length());            //容器中的字元個數,實際值
        System.out.println(sb.capacity());          //容器的初始容量,理論值

        StringBuffer sb2 = new StringBuffer();
        System.out.println(sb2.length());
        System.out.println(sb2.capacity());

        StringBuffer sb3 = new StringBuffer("heima");
        System.out.println(sb3.length());           //實際字元的個數
        System.out.println(sb3.capacity());         //字元串的length + 初始容量

    }

}

13.03_常見對象(StringBuffer的添加功能)

A:StringBuffer的添加功能
- public StringBuffer append(String str):
  - 可以把任意類型資料添加到字元串緩沖區裡面,并傳回字元串緩沖區本身
- public StringBuffer insert(int offset,String str):
  - 在指定位置把任意類型的資料插入到字元串緩沖區裡面,并傳回字元串緩沖區本身

package com.heima.stringbuffer;

public class Demo2_StringBuffer {

    /**
     * * A:StringBuffer的添加功能
        * public StringBuffer append(String str):
            * 可以把任意類型資料添加到字元串緩沖區裡面,并傳回字元串緩沖區本身
        * public StringBuffer insert(int offset,String str):
            * 在指定位置把任意類型的資料插入到字元串緩沖區裡面,并傳回字元串緩沖區本身
        StringBuffer是字元串緩沖區,當new的時候是在堆記憶體建立了一個對象,底層是一個長度為16的字元數組
        當調用添加的方法時,不會再重新建立對象,在不斷向原緩沖區添加字元
     */
    public static void main(String[] args) {
        //demo1();
        StringBuffer sb = new StringBuffer("1234");
        sb.insert(, "heima");                      //在指定位置添加元素,如果沒有指定位置的索引就會報索引越界異常

        System.out.println(sb);
    }

    private static void demo1() {
        StringBuffer sb = new StringBuffer();
        StringBuffer sb2 = sb.append(true);
        StringBuffer sb3 = sb.append("heima");
        StringBuffer sb4 = sb.append();


        System.out.println(sb.toString());          //StringBuffer類中重寫了toString方法,顯示的是對象中的屬性值
        System.out.println(sb2.toString());
        System.out.println(sb3.toString());
        System.out.println(sb4.toString());
    }

}

13.04_常見對象(StringBuffer的删除功能)

A:StringBuffer的删除功能
- public StringBuffer deleteCharAt(int index):
  - 删除指定位置的字元，并傳回本身
- public StringBuffer delete(int start,int end):
  - 删除從指定位置開始指定位置結束的内容，并傳回本身

package com.heima.stringbuffer;

public class Demo3_StringBuffer {

    /**
     * * A:StringBuffer的删除功能
        * public StringBuffer deleteCharAt(int index):
            * 删除指定位置的字元，并傳回本身
        * public StringBuffer delete(int start,int end):
            * 删除從指定位置開始指定位置結束的内容，并傳回本身
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //sb.deleteCharAt(5);                   //當緩沖區中這個索引上沒有元素的時候就會報StringIndexOutOfBoundsException
        sb.append("heima");
        //sb.deleteCharAt(4);                   //根據索引删除掉索引位置上對應的字元
        //sb.delete(0, 2);                      //删除的時候是包含頭,不包含尾
        //System.out.println(sb);
        //sb.delete(0, sb.length());                //清空緩沖區
        //System.out.println(sb);

        sb = new StringBuffer();                //不要用這種方式清空緩沖區,原來的會變成垃圾,浪費記憶體
        System.out.println(sb);
    }

}

13.05_常見對象(StringBuffer的替換和反轉功能)

A:StringBuffer的替換功能
- public StringBuffer replace(int start,int end,String str):
  - 從start開始到end用str替換
B:StringBuffer的反轉功能
- public StringBuffer reverse():
  - 字元串反轉

package com.heima.stringbuffer;

public class Demo4_StringBufferMethod {

    /**
     * * A:StringBuffer的替換功能
            * public StringBuffer replace(int start,int end,String str):
                * 從start開始到end用str替換
        * B:StringBuffer的反轉功能
            * public StringBuffer reverse():
                * 字元串反轉
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("我愛總複習");
        //sb.replace(0, 3, "bai");                  //替換
        //System.out.println(sb);

        sb.reverse();
        System.out.println(sb);
    }

}

13.06_常見對象(StringBuffer的截取功能及注意事項)

A:StringBuffer的截取功能
- public String substring(int start):
  - 從指定位置截取到末尾
- public String substring(int start,int end):
  - 截取從指定位置開始到結束位置，包括開始位置，不包括結束位置
B:注意事項
- 注意:傳回值類型不再是StringBuffer本身

package com.heima.stringbuffer;

public class Demo5_StringBufferMethod {

    /**
     * * A:StringBuffer的截取功能
        * public String substring(int start):
            * 從指定位置截取到末尾
        * public String substring(int start,int end):
            * 截取從指定位置開始到結束位置，包括開始位置，不包括結束位置
    * B:注意事項
        * 注意:傳回值類型不再是StringBuffer本身
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("woaiheima");
        //String str = sb.substring(4);
        //System.out.println(str);

        //System.out.println(sb);

        String str3 = sb.substring(, );
        System.out.println(str3);
    }

}

13.07_常見對象(StringBuffer和String的互相轉換)

A:String – StringBuffer
- a:通過構造方法
- b:通過append()方法
B:StringBuffer – String
- a:通過構造方法
- b:通過toString()方法
- c:通過subString(0,length);

package com.heima.stringbuffer;

public class Demo6_StringBuffer {

    /**
     * * A:String -- StringBuffer
        * a:通過構造方法
        * b:通過append()方法
    * B:StringBuffer -- String
        * a:通過構造方法
        * b:通過toString()方法
        * c:通過subString(0,length);

     */
    public static void main(String[] args) {
        //demo1();
        StringBuffer sb = new StringBuffer("heima");

        String s1 = new String(sb);                     //通過構造将StringBuffer轉換為String
        System.out.println(s1);

        String s2 = sb.toString();                      //通過toString方法将StringBuffer轉換為String
        System.out.println(s2);

        String s3 = sb.substring(, sb.length());       //通過截取子字元串将StringBuffer轉換為String
        System.out.println(s3);
    }

    private static void demo1() {
        StringBuffer sb1 = new StringBuffer("heima");           //通過構造方法将字元串轉換為StringBuffer對象
        System.out.println(sb1);

        StringBuffer sb2 = new StringBuffer();
        sb2.append("heima");                                    //通過append方法将字元串轉換為StringBuffer對象
        System.out.println(sb2);
    }

}

13.08_常見對象(把數組轉成字元串)

A:案例示範

需求：把數組中的資料按照指定個格式拼接成一個字元串

舉例：
    int[] arr = {1,2,3};    
輸出結果：
    "[1, 2, 3]"

用StringBuffer的功能實作

package com.heima.test;

public class Test1 {

    /**
     * * 需求：把數組中的資料按照指定個格式拼接成一個字元串
    * 
            舉例：
                int[] arr = {1,2,3};    
            輸出結果：
                "[1, 2, 3]"

            用StringBuffer的功能實作
     */
    public static void main(String[] args) {
        int[] arr = {,,};
        System.out.println(arrayToString(arr));
    }

    /*
     * 将數組轉換為字元串
     * 1,傳回值類型String
     * 2,參數清單int[]
     * 
     * arrayToString 将數組轉換為字元串
     * array2String     2與to的發音一樣就用2替換了to,後來演變成了一種書寫習慣
     * dom4j  domForJ
     */

    public static String arrayToString(int[] arr) {
        StringBuffer sb = new StringBuffer();               //建立字元串緩沖區對象
        sb.append("[");                                     //将[添加到緩沖區


        //{1,2,3}
        for (int i = ; i < arr.length; i++) {              //周遊數組
            //sb.append(arr[i] + ", ");                     //這樣做沒有]
            if(i == arr.length - ) {
                sb.append(arr[i]).append("]");              //[1, 2, 3]
            }else {
                sb.append(arr[i]).append(", ");             //[1, 2,
            }
        }
        return sb.toString();
    }
}

13.09_常見對象(字元串反轉)

A:案例示範

需求：把字元串反轉
    舉例：鍵盤錄入"abc"        
    輸出結果："cba"

用StringBuffer的功能實作

package com.heima.test;

import java.util.Scanner;

public class Test2 {

    /**
     * * A:案例示範
    * 
            需求：把字元串反轉
                舉例：鍵盤錄入"abc"        
                輸出結果："cba"

            用StringBuffer的功能實作  
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);                //建立鍵盤錄入對象
        String line = sc.nextLine();                        //将鍵盤錄入的字元串存儲在line中

        /*StringBuffer sb = new StringBuffer(line);         //将字元串轉換為StringBuffer對象
        sb.reverse();                                       //将緩沖區的内容反轉

        System.out.println(sb.toString());*/

        System.out.println(revString(line));
    }

    /*
     * 将字元串反轉
     * 1,傳回值類型String
     * 2,參數清單String line
     */

    public static String revString(String line) {
        StringBuffer sb = new StringBuffer(line);           //将字元串轉換為StringBuffer對象
        sb.reverse();                                       //将緩沖區的内容反轉

        return sb.toString();
    }
}

13.10_常見對象(StringBuffer和StringBuilder的差別)

A:StringBuilder的概述
- 通過檢視API了解一下StringBuilder類
B:面試題
- String,StringBuffer,StringBuilder的差別
- StringBuffer和StringBuilder的差別
- StringBuffer是jdk1.0版本的,是線程安全的,效率低
- StringBuilder是jdk1.5版本的,是線程不安全的,效率高
- String和StringBuffer,StringBuilder的差別
- String是一個不可變的字元序列
- StringBuffer,StringBuilder是可變的字元序列

13.11_常見對象(String和StringBuffer分别作為參數傳遞)

A:形式參數問題
- String作為參數傳遞
- StringBuffer作為參數傳遞
B:案例示範
- String和StringBuffer分别作為參數傳遞問題

package com.heima.stringbuffer;

public class Demo7_StringBuffer {

    /**
     * * A:形式參數問題
            * String作為參數傳遞
            * StringBuffer作為參數傳遞 
        * B:案例示範
            * String和StringBuffer分别作為參數傳遞問題
            * 
    基本資料類型的值傳遞,不改變其值
    引用資料類型的值傳遞,改變其值

    String類雖然是引用資料類型,但是他當作參數傳遞時和基本資料類型是一樣的
     */
    public static void main(String[] args) {
        String s = "heima";
        System.out.println(s);
        change(s);
        System.out.println(s);


        System.out.println("---------------------");
        StringBuffer sb = new StringBuffer();
        sb.append("heima");
        System.out.println(sb);
        change(sb);
        System.out.println(sb);
    }

    public static void change(StringBuffer sb) {
        sb.append("itcast");
    }

    public static void change(String s) {
        s += "itcast";
    }

}

13.12_常見對象(數組進階冒泡排序原理圖解)

A:畫圖示範

需求：
    數組元素：{24, 69, 80, 57, 13}
    請對數組元素進行排序。

    冒泡排序
        相鄰元素兩兩比較，大的往後放，第一次完畢，最大值出現在了最大索引處

13-StringBuffer類的概述/數組冒泡/二分查找/Arrays類/Integer類

13.13_常見對象(數組進階冒泡排序代碼實作)

A:案例示範
- 數組進階冒泡排序代碼

package com.heima.array;

public class Demo1_Array {

    /**
     * * A:案例示範
    * 數組進階冒泡排序代碼
     */
    public static void main(String[] args) {
        int[] arr = {, , , , };
        bubbleSort(arr);
        //selectSort(arr);
        print(arr);
    }

    /*
     * 冒泡排序
     * 1,傳回值類型,void
     * 2,參數清單,int[] arr
     * 
     *  第一次:arr[0]與arr[1],arr[1]與arr[2],arr[2]與arr[3],arr[3]與arr[4]比較4次
        第二次:arr[0]與arr[1],arr[1]與arr[2],arr[2]與arr[3]比較3次
        第三次:arr[0]與arr[1],arr[1]與arr[2]比較2次
        第四次:arr[0]與arr[1]比較1次
     */

    public static void bubbleSort(int[] arr) {
        for (int i = ; i < arr.length - ; i++) {              //外循環隻需要比較arr.length-1次就可以了
            for (int j = ; j < arr.length -  - i; j++) {      //-1為了防止索引越界,-i為了提高效率
                if(arr[j] > arr[j+]) {
                    /*int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j+1] = temp;*/
                    swap(arr,j,j+);
                }
            }
        }
    }

    /*
     * 列印數組
     * 1,傳回值類型void
     * 2,參數清單int[]arr
     */

    public static void print(int[] arr) {
        for (int i = ; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    /*
     * 選擇排序
     * 1,傳回值類型void
     * 2,參數清單int[] arr
     * 
     *  第一次:arr[0]分别與arr[1-4]比較,比較4次
        第二次:arr[1]分别與arr[2-4]比較,比較3次
        第三次:arr[2]分别與arr[3-4]比較,比較2次
        第四次:arr[3]與arr[4]比較,比較1次
     */

    public static void selectSort(int[] arr) {
        for (int i = ; i < arr.length - ; i++) {              //隻需要比較arr.length-1次
            for (int j = i + ; j < arr.length; j++) {
                if(arr[i] > arr[j]) {
                    /*int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;*/
                    swap(arr,i,j);
                }
            }
        }
    }

    /*
     * 換位操作
     * 1,傳回值類型,void
     * 2,參數清單int[] arr.int i,int j
     * 
     * 如果某個方法,隻針對本類使用,不想讓其他類使用就可以定義成私有的
     */

    private static void swap(int[] arr,int i,int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

13.14_常見對象(數組進階選擇排序原理圖解)

A:畫圖示範
- 需求：
  - 數組元素：{24, 69, 80, 57, 13}
  - 請對數組元素進行排序。
  - 選擇排序
    - 從0索引開始，依次和後面元素比較，小的往前放，第一次完畢，最小值出現在了最小索引處
      
      13-StringBuffer類的概述/數組冒泡/二分查找/Arrays類/Integer類

13.15_常見對象(數組進階選擇排序代碼實作)

A:案例示範
- 數組進階選擇排序代碼

package com.heima.array;

import java.util.Arrays;

public class Demo3_Arrays {

    /**
        * public static String toString(int[] a)
        * public static void sort(int[] a)
        * public static int binarySearch(int[] a,int key)
        * 
        *  public static String toString(int[] a) {
                if (a == null)                              //如果傳入的數組是null
                    return "null";                          //傳回null
                int iMax = a.length - ;                    //iMax最大索引
                if (iMax == -)                             //如果數組中沒有元素
                    return "[]";                            //傳回[]

                StringBuilder b = new StringBuilder();      //線程不安全,效率高
                b.append('[');                              //将[添加到字元串緩沖區中
                for (int i = ; ; i++) {                    //周遊數組,判斷語句沒有寫預設是true
                    b.append(a[i]);                         //把第一個元素添加進字元串緩沖區
                    if (i == iMax)                          //如果索引等于了最大索引值
                        return b.append(']').toString();    //将]添加到字元串緩沖區,在轉換成字元串并傳回
                    b.append(", ");                         //如果不等于最大索引就将, 添加到緩沖區
                }
            }

         private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
                int low = fromIndex;                //最小索引0
                int high = toIndex - ;             //最大索引數組長度-1

                while (low <= high) {               //最小索引小于等于最大索引可以循環判斷
                    int mid = (low + high) >>> ;   //求出中間索引值,(最小+最大)/2
                    int midVal = a[mid];            //通過中間索引擷取中間值

                    if (midVal < key)               //中間索引對應的值小于查找的值
                        low = mid + ;              //最小索引變化
                    else if (midVal > key)          //中間索引對應的值大于查找的值
                        high = mid - ;             //最大索引變化
                    else
                        return mid; // key found    //找到了
                }
                return -(low + );  // key not found.//-插入點 - 1
            }
     */
    public static void main(String[] args) {
        int[] arr = {,,,,,};
        System.out.println(Arrays.toString(arr));           //數組轉字元串

        Arrays.sort(arr);                                   //排序
        System.out.println(Arrays.toString(arr));

        int[] arr2 = {,,,,,};
        System.out.println(Arrays.binarySearch(arr2, ));
        System.out.println(Arrays.binarySearch(arr2, ));
        System.out.println(Arrays.binarySearch(arr2, ));   //-插入點-1
    }

}

13.16_常見對象(數組進階二分查找原理圖解)

A:畫圖示範
- 二分查找
- 前提：數組元素有序
  
  13-StringBuffer類的概述/數組冒泡/二分查找/Arrays類/Integer類

13.17_常見對象(數組進階二分查找代碼實作及注意事項)

A:案例示範
- 數組進階二分查找代碼
B:注意事項
- 如果數組無序，就不能使用二分查找。
  - 因為如果你排序了，但是你排序的時候已經改變了我最原始的元素索引。

package com.heima.array;

public class Demo2_Array {

    /**
     * * A:案例示範
            * 數組進階二分查找代碼
        * B:注意事項
            * 如果數組無序，就不能使用二分查找。
                * 因為如果你排序了，但是你排序的時候已經改變了我最原始的元素索引。

     */
    public static void main(String[] args) {
        int[] arr = {,,,,,,};
        System.out.println(getIndex(arr, ));
        System.out.println(getIndex(arr, ));
        System.out.println(getIndex(arr, ));
    }

    /*
     * 二分查找
     * 1,傳回值類型,int
     * 2,參數清單int[] arr,int value
     */

    public static int getIndex(int[] arr, int value) {
        int min = ;
        int max = arr.length - ;
        int mid = (min + max) / ;

        while(arr[mid] != value) {                  //當中間值不等于要找的值,就開始循環查找
            if(arr[mid] < value) {                  //當中間值小于了要找的值
                min = mid + ;                      //最小的索引改變
            }else if (arr[mid] > value){            //當中間值大于了要找的值
                max = mid - ;                      //最大的索引改變
            }

            mid = (min + max) / ;                  //無論最大還是最小改變,中間索引都會随之改變

            if(min > max) {                         //如果最小索引大于了最大索引,就沒有查找的可能性了
                return -;                          //傳回-1
            }
        }
        return mid;
    }
}

13.18_常見對象(Arrays類的概述和方法使用)

A:Arrays類概述
- 針對數組進行操作的工具類。
- 提供了排序，查找等功能。
B:成員方法
- public static String toString(int[] a)
- public static void sort(int[] a)
- public static int binarySearch(int[] a,int key)

13.19_常見對象(基本類型包裝類的概述)

A:為什麼會有基本類型包裝類
- 将基本資料類型封裝成對象的好處在于可以在對象中定義更多的功能方法操作該資料。
B:常用操作
- 常用的操作之一：用于基本資料類型與字元串之間的轉換。
C:基本類型和包裝類的對應
byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

package com.heima.wrapclass;

public class Demo1_Integer {

    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString());
        System.out.println(Integer.toOctalString());
        System.out.println(Integer.toHexString());
    }

}

13.20_常見對象(Integer類的概述和構造方法)

A:Integer類概述
- 通過JDK提供的API，檢視Integer類的說明
- Integer 類在對象中包裝了一個基本類型 int 的值,
- 該類提供了多個方法，能在 int 類型和 String 類型之間互相轉換，
- 還提供了處理 int 類型時非常有用的其他一些常量和方法
B:構造方法
- public Integer(int value)
- public Integer(String s)
C:案例示範
- 使用構造方法建立對象

package com.heima.wrapclass;

public class Demo2_Integer {

    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        Integer i1 = new Integer();
        System.out.println(i1);

        //Integer i2 = new Integer("abc");          //java.lang.NumberFormatException數字格式異常
        //System.out.println(i2);                       //因為abc不是數字字元串,是以轉換會報錯

        Integer i3 = new Integer("100");
        System.out.println(i3);
    }

}

13.21_常見對象(String和int類型的互相轉換)

A:int – String
- a:和”“進行拼接
- b:public static String valueOf(int i)
- c:int – Integer – String(Integer類的toString方法())
- d:public static String toString(int i)(Integer類的靜态方法)
B:String – int
- a:String – Integer – int
- public static int parseInt(String s)

package com.heima.wrapclass;

public class Demo3_Integer {

    /**
     * * A:int -- String
            * a:和""進行拼接
            * b:public static String valueOf(int i)
            * c:int -- Integer -- String(Integer類的toString方法())
            * d:public static String toString(int i)(Integer類的靜态方法)
        * B:String -- int
            * a:String -- Integer -- int
                * public static int parseInt(String s)
        基本資料類型包裝類有八種,其中七種都有parseXxx的方法,可以将這七種的字元串表現形式轉換成基本資料類型
     */
    public static void main(String[] args) {

        //demo1();
        String s1 = "true";
        boolean b = Boolean.parseBoolean(s1);
        System.out.println(b);

        //String s2 = "abc";
        //char c = Character.p      //char的包裝類Character中沒有pareseXxx的方法
                                    //字元串到字元的轉換通過toCharArray()就可以把字元串轉換為字元數組
    }

    private static void demo1() {
        //int ----> String int轉換成String
        int i = ;
        String s1 = i + "";                     //推薦用
        String s2 = String.valueOf(i);          //推薦用

        Integer i2 = new Integer(i);
        String s3 = i2.toString();

        String s4 = Integer.toString(i);
        System.out.println(s1);

        //String----> int String 轉換int
        String s = "200";
        Integer i3 = new Integer(s);
        int i4 = i3.intValue();                 //将Integer轉換成了int數

        int i5 = Integer.parseInt(s);           //将String轉換為int,推薦用這種
    }

}

13.22_常見對象(JDK5的新特性自動裝箱和拆箱)

A:JDK5的新特性
- 自動裝箱：把基本類型轉換為包裝類類型
- 自動拆箱：把包裝類類型轉換為基本類型
B:案例示範
- JDK5的新特性自動裝箱和拆箱
- Integer ii = 100;
- ii += 200;
C:注意事項
- 在使用時，Integer x = null;代碼就會出現NullPointerException。
- 建議先判斷是否為null，然後再使用。

package com.heima.wrapclass;

public class Demo4_JDK5 {

    public static void main(String[] args) {
//      int x = 100;
//      Integer i1 = new Integer(x);            //将基本資料類型包裝成對象,裝箱
//      
//      int y = i1.intValue();                  //将對象轉換為基本資料類型,拆箱

        Integer i2 = ;                       //自動裝箱,把基本資料類型轉換成對象
        int z = i2 + ;                       //自動拆箱,把對象轉換為基本資料類型
        System.out.println(z);

        Integer i3 = null;
        int a = i3 + ;                       //底層用i3調用intValue,但是i3是null,null調用方法就會出現
        System.out.println(a);                  //空指針異常java.lang.NullPointerException
    }

}

13.23_常見對象(Integer的面試題)

A:Integer的面試題

看程式寫結果

Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
System.out.println("-----------");

Integer i3 = new Integer(197);
Integer i4 = new Integer(197);
System.out.println(i3 == i4);
System.out.println(i3.equals(i4));
System.out.println("-----------");

Integer i5 = 97;
Integer i6 = 97;
System.out.println(i5 == i6);
System.out.println(i5.equals(i6));
System.out.println("-----------");

Integer i7 = 197;
Integer i8 = 197;
System.out.println(i7 == i8);
System.out.println(i7.equals(i8));

package com.heima.wrapclass;


public class Demo5_Integer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Integer i1 = new Integer();
        Integer i2 = new Integer();
        System.out.println(i1 == i2);               //false
        System.out.println(i1.equals(i2));          //true
        System.out.println("-----------");

        Integer i3 = new Integer();
        Integer i4 = new Integer();
        System.out.println(i3 == i4);               //false
        System.out.println(i3.equals(i4));          //true
        System.out.println("-----------");

        Integer i5 = ;
        Integer i6 = ;
        System.out.println(i5 == i6);               //true
        System.out.println(i5.equals(i6));          //true
        System.out.println("-----------");

        Integer i7 = ;
        Integer i8 = ;
        System.out.println(i7 == i8);
        System.out.println(i7.equals(i8));          //true

        /*
         * -128到127是byte的取值範圍,如果在這個取值範圍内,自動裝箱就不會新建立對象,而是從常量池中擷取
         * 如果超過了byte取值範圍就會再新建立對象
         * 
         * public static Integer valueOf(int i) {
                assert IntegerCache.high >= 127;
                if (i >= IntegerCache.low && i <= IntegerCache.high)            //i>= -128 && i <= 127
                    return IntegerCache.cache[i + (-IntegerCache.low)];
                return new Integer(i);
            }
         */
    }

}

13-StringBuffer類的概述/數組冒泡/二分查找/Arrays類/Integer類

13.01_常見對象(StringBuffer類的概述)

13.02_常見對象(StringBuffer類的構造方法)

13.03_常見對象(StringBuffer的添加功能)

13.04_常見對象(StringBuffer的删除功能)

13.05_常見對象(StringBuffer的替換和反轉功能)

13.06_常見對象(StringBuffer的截取功能及注意事項)

13.07_常見對象(StringBuffer和String的互相轉換)

13.08_常見對象(把數組轉成字元串)

13.09_常見對象(字元串反轉)

13.10_常見對象(StringBuffer和StringBuilder的差別)

13.11_常見對象(String和StringBuffer分别作為參數傳遞)

13.12_常見對象(數組進階冒泡排序原理圖解)

13.13_常見對象(數組進階冒泡排序代碼實作)

13.14_常見對象(數組進階選擇排序原理圖解)

13.15_常見對象(數組進階選擇排序代碼實作)

13.16_常見對象(數組進階二分查找原理圖解)

13.17_常見對象(數組進階二分查找代碼實作及注意事項)

13.18_常見對象(Arrays類的概述和方法使用)

13.19_常見對象(基本類型包裝類的概述)

13.20_常見對象(Integer類的概述和構造方法)

13.21_常見對象(String和int類型的互相轉換)

13.22_常見對象(JDK5的新特性自動裝箱和拆箱)

13.23_常見對象(Integer的面試題)

繼續閱讀