Java編程基礎(chǔ)14——常見對象_StringBuffer&數(shù)組排序&包裝類

banana_pi 發(fā)布于2019-08-19 11:10 / 2356人閱讀

摘要：提供了排序，查找等功能。常用操作常用的操作之一用于基本數(shù)據(jù)類型與字符串之間的轉(zhuǎn)換。

1_StringBuffer類的概述

A:StringBuffer類概述

通過JDK提供的API，查看StringBuffer類的說明

線程安全的可變字符序列 (一個類似于 String 的字符串緩沖區(qū)，但不能修改 : 不能像String那樣用 + 連接來修改String)

B:StringBuffer和String的區(qū)別

String是一個不可變的字符序列

StringBuffer是一個可變的字符序列

"線程安全的"的簡單理解:線程安全的,是同步的,效率低

2_StringBuffer類的構(gòu)造方法

A:StringBuffer的構(gòu)造方法：

public StringBuffer():無參構(gòu)造方法

public StringBuffer(int capacity):指定容量的字符串緩沖區(qū)對象

public StringBuffer(String str):指定字符串內(nèi)容的字符串緩沖區(qū)對象

B:StringBuffer的方法：

public int capacity()：返回當(dāng)前容量。理論值(不掌握)

public int length(): 返回長度（容器中的字符個數(shù)）。實際值

C:案例演示

構(gòu)造方法和長度方法的使用

    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.length());            //容器中的字符個數(shù)
        System.out.println(sb.capacity());            //容器的初始容量，理論值
        
        StringBuffer sb2 = new StringBuffer(10);
        System.out.println(sb2.length());            
        System.out.println(sb2.capacity());    

        StringBuffer sb3 = new StringBuffer("allidea");
        System.out.println(sb3.length());            //實際字符的個數(shù)
        System.out.println(sb3.capacity());            //字符串的length + 初始容量    
    }

3_StringBuffer的添加功能

A:StringBuffer的添加功能

public StringBuffer append(String str):

可以把任意類型數(shù)據(jù)添加到字符串緩沖區(qū)里面,并返回字符串緩沖區(qū)本身

StringBuffer是字符串緩沖區(qū),當(dāng)new的時候是在堆內(nèi)存創(chuàng)建了一個對象,底層是一個長度為16的字符數(shù)組
當(dāng)調(diào)用添加的方法時,不會再重新創(chuàng)建對象,而是在不斷向原緩沖區(qū)添加字符

public StringBuffer insert(int offset,String str):

在指定位置把任意類型的數(shù)據(jù)插入到字符串緩沖區(qū)里面,并返回字符串緩沖區(qū)本身

StringBuffer是字符串緩沖區(qū)，當(dāng)new的時候是在堆內(nèi)存創(chuàng)建了一個對象，底層是一個長度為16的字符數(shù)組，當(dāng)調(diào)用添加的方法時，不會重新創(chuàng)建對象，在不斷的向原緩沖區(qū)加字符

public class StringBuffer_2 {
    public static void main(String[] args) {
//        demo1();
        StringBuffer sb = new StringBuffer("1234");
        sb.insert(3,"allidea");        //在指定位置添加元素，如果沒有指定位置的索引，就會報索引越界異常
        System.out.println(sb);
    }
    private static void demo1() {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.toString());
        StringBuffer sb2 = sb.append(true);
        System.out.println(sb2.toString());
        StringBuffer sb3 = sb.append("allidea");
        System.out.println(sb3.toString());
        StringBuffer sb4 = sb.append(100);
        System.out.println(sb4.toString());
    }
}

4_StringBuffer的刪除功能

A:StringBuffer的刪除功能

public StringBuffer deleteCharAt(int index):

刪除指定位置的字符，并返回本身

public StringBuffer delete(int start,int end):

刪除從指定位置開始指定位置結(jié)束的內(nèi)容，并返回本身

    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
//        sb.deleteCharAt(5);            //當(dāng)緩沖區(qū)這個索引上沒有元素時就會報StringIndexOutOfBoundsException
        sb.append("allidea");
//        sb.deleteCharAt(4);            //根據(jù)索引刪除索引位置上對應(yīng)的字符
//        sb.delete(0, 3);            //刪除的時候是包含頭不包含尾
//        System.out.println(sb);
//        sb.delete(0, sb.length());    //清空緩沖區(qū)
//        System.out.println(sb);
        
        sb = new StringBuffer();    //不要用這種方式清空內(nèi)存，原來的會變成垃圾，浪費內(nèi)存。
        System.out.println(sb);
    }

5_StringBuffer的替換和反轉(zhuǎn)功能

A:StringBuffer的替換功能

public StringBuffer replace(int start,int end,String str):

從start開始到end用str替換

B:StringBuffer的反轉(zhuǎn)功能

public StringBuffer reverse():

字符串反轉(zhuǎn)

        StringBuffer sb = new StringBuffer("我愛java");
//        sb.replace(0, 3, "ALL");        //替換
//        System.out.println(sb);
        
        sb.reverse();
        System.out.println(sb);            //反轉(zhuǎn)

6_StringBuffer的截取功能及注意事項

A:StringBuffer的截取功能

public String substring(int start):

從指定位置截取到末尾

public String substring(int start,int end):

截取從指定位置開始到結(jié)束位置，包括開始位置，不包括結(jié)束位置

B:注意事項

注意:返回值類型不再是StringBuffer本身

        StringBuffer sb = new StringBuffer("我愛java");
//        String str = sb.substring(2);
//        System.out.println(str);
        
        String str2 = sb.substring(2,sb.length());
        System.out.println(str2);

7_StringBuffer和String的相互轉(zhuǎn)換

A:String -- StringBuffer

a:通過構(gòu)造方法

b:通過append()方法

B:StringBuffer -- String

a:通過構(gòu)造方法

b:通過toString()方法

c:通過subString(0,length);

    public static void main(String[] args) {
//        demo1();
        StringBuffer sb = new StringBuffer("allidea");
        
        String s1 = new String(sb);            //通過構(gòu)造將StringBuffer轉(zhuǎn)換為String
        System.out.print(s1);
        
        String s2 = sb.toString();            //通過toString將StringBuffer轉(zhuǎn)換為String
        System.out.println(s2);
        
        String s3 = sb.substring(0,sb.length());//通過截取字符串將StringBuffer轉(zhuǎn)換為String
        System.out.println(s3);
    }

    private static void demo1() {
        StringBuffer sb1 = new StringBuffer("allidea");        //通過構(gòu)造方法將字符串轉(zhuǎn)換為StringBuffer對象
        System.out.println(sb1);
        
        StringBuffer sb2 = new StringBuffer();
        sb2.append("allidea");                                //通過append方法轉(zhuǎn)換為StringBuffer對象
        System.out.println(sb2);
    }

8_把數(shù)組轉(zhuǎn)成字符串

A:案例演示-需求：把數(shù)組中的數(shù)據(jù)按照指定個格式拼接成一個字符串
舉例：

int[] arr = {1,2,3};

輸出結(jié)果：

"[1, 2, 3]"

用StringBuffer的功能實現(xiàn)

public class StringBuffer_test_7 {            
    public static void main(String[] args) {
        int[] arr = {1,2,3};    
        System.out.println(arrayToString(arr));
    }
    /*將數(shù)組轉(zhuǎn)換為字符串
     * 1.返回值類型String
     * 2.參數(shù)列表int[]
     * 
     * arrayToString 將數(shù)組轉(zhuǎn)換為字符串
     * dom4j  domForJ
     * */
    public static String arrayToString(int[] arr) {
        StringBuffer sb = new StringBuffer();            //創(chuàng)建字符串緩沖區(qū)對象
        sb.append("[");                                    //將[添加到緩沖區(qū)
        
        for (int i = 0; i < arr.length; i++) {            //遍歷數(shù)組
//            sb.append(arr[i] + ", ");                    //沒有]
            if (i != arr.length - 1) {
                sb.append(arr[i]).append(",");
            } else {
                sb.append(arr[i]).append("]");
            }
        }
        return sb.toString();
    }
}

9_字符串反轉(zhuǎn)

A:案例演示-需求：把字符串反轉(zhuǎn)

舉例：鍵盤錄入"abc"    輸出結(jié)果："cba

用StringBuffer的功能實現(xiàn)

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個字符串：");
        String line = sc.nextLine();
        
//        StringBuffer sb = new StringBuffer(line);    //將字符串轉(zhuǎn)換為StringBuffer對象
//        sb.reverse();                                //將緩沖區(qū)內(nèi)容反轉(zhuǎn)
//        System.out.println(sb.toString());
        
        System.out.println(revString(line));
    }
    
/*    將字符串反轉(zhuǎn)
    1.返回值類型string
    2.參數(shù)列表string line*/
    
    public static String revString(String line) {    
        StringBuffer sb = new StringBuffer(line);    //將字符串轉(zhuǎn)換為StringBuffer對象
        sb.reverse();    
        return sb.toString();
    }

10_StringBuffer和StringBuilder的區(qū)別

A:StringBuilder的概述

通過查看API了解一下StringBuilder類

B:面試題

String,StringBuffer,StringBuilder的區(qū)別

StringBuffer和StringBuilder的區(qū)別

StringBuffer是jdk1.0版本的,是線程安全的,效率低

StringBuilder是jdk1.5版本的,是線程不安全的,效率高

String和StringBuffer,StringBuilder的區(qū)別

String是一個不可變的字符序列

StringBuffer,StringBuilder是可變的字符序列

11_String和StringBuffer分別作為參數(shù)傳遞

A:形式參數(shù)問題

String作為參數(shù)傳遞

StringBuffer作為參數(shù)傳遞

B:案例演示

String和StringBuffer分別作為參數(shù)傳遞問題

    基本數(shù)據(jù)類型的值傳遞,不改變其值
    引用數(shù)據(jù)類型的值傳遞,改變其值
    String類雖然是引用數(shù)據(jù)類型,但是他當(dāng)作參數(shù)傳遞時和基本數(shù)據(jù)類型是一樣的(因為String類一旦被初始化,就不會被改變決定的)
     
    public static void main(String[] args) {
        String s = "allidea";
        System.out.println(s);
        change(s);
        System.out.println(s);
        
        StringBuffer sb = new StringBuffer();
        sb.append("allidea");
        System.out.println(sb);
        change(sb);
        System.out.println(sb);
    }
    public static void change(String s) {
        s += "net";
    }
    public static void change(StringBuffer sb) {
        sb.append("net");
    }

12_數(shù)組高級冒泡排序

A:原理圖解-畫圖演示

需求：
    數(shù)組元素：{24, 69, 80, 57, 13}
    請對數(shù)組元素進(jìn)行排序。
    冒泡排序
        相鄰元素兩兩比較，大的往后放，第一次完畢，最大值出現(xiàn)在了最大索引處

B:代碼實現(xiàn)-案例演示

數(shù)組高級冒泡排序代碼

public class Array_1 {
    //高級冒泡排序
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
        bubbleSort(arr);
        print(arr);
    }
/*    冒泡排序方法：
    1.返回類型，void
    2.參數(shù)列表，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 = 0; i < arr.length - 1; i++) {//外循環(huán)只需要比較arr.length-1次就行了
            for (int j = 0; j < arr.length - 1 - i; j++) {//-1防止索引越界,-i為了提高效率
                if(arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    //swap(arr,j,j+1);
                }
            }
        }
    }
/*    打印數(shù)組
    1.返回值類型void
    2.參數(shù)列表，int[] arr*/
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

13_數(shù)組高級選擇排序

A:原理圖解-畫圖演示：

數(shù)組元素：{24, 69, 80, 57, 13}

請對數(shù)組元素進(jìn)行排序。

選擇排序

從0索引開始，依次和后面元素比較，小的往前放，第一次完畢，最小值出現(xiàn)在了最小索引處

用一個索引位置上的元素，依次與其他索引位置上的元素比較，小的在前，大的在后

B:代碼實現(xiàn)-案例演示

數(shù)組高級選擇排序代碼

public class Array_2 {
    //高級選擇排序
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
//        bubbleSort(arr);
        selectSort(arr);
        print(arr);
    }

/*    打印數(shù)組
    1.返回值類型void
    2.參數(shù)列表，int[] arr*/
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    
/*    選擇排序
    1.返回值類型void
    2.參數(shù)列表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 = 0; i < arr.length - 1; i++) {//字需要比較arr.length-1次
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]) {
                    swap(arr,i,j);
                }
            }
        }
    }
    
/*    換位操作
    1.返回值類型：void
    2.參數(shù)列表：int[],arr.int i,int j
    如果某個方法，只針對本類使用，不想讓其他類使用就可以定義成私有的
    */
    
    ublic static void swap(int[] arr,int i,int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

14_數(shù)組高級二分查找

A:原理圖解-畫圖演示

二分查找: 查找元素對應(yīng)的索引

前提：數(shù)組元素有序

B:代碼實現(xiàn)-案例演示

數(shù)組高級二分查找代碼

C:注意事項

如果數(shù)組無序，就不能使用二分查找。

因為如果你排序了，但是你排序的時候已經(jīng)改變了我最原始的元素索引。

public class Array_3 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77,88,99};
        System.out.println(getIndex(arr, 22));
        System.out.println(getIndex(arr, 99));
    }
/*    二分查詢
    1.返回值類型：int
    2.參數(shù)列表int[] arr,int value*/
    public static int getIndex(int[] arr,int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;
        
        while(arr[mid] != value) {            //當(dāng)中間值不等于要找的值，就開始循環(huán)查找
            if(arr[mid] < value) {            //當(dāng)中間值小于了要找的值
                min = mid + 1;                //最小的索引改變
            }else if(arr[mid] > value) {    //當(dāng)中間值大雨了要找的值
                max = mid - 1;                //最大的索引改變
            }
            mid = (min + max) / 2;            //無論最大還是最小改變，中間索引都會隨之改變
            
            if(min > max) {                    //如果最小索引大于了最大索引，就沒有查找的可能性了，返回-1
                return -1;
            }
        }
        return mid;
    }
}

15_Arrays類的概述和方法使用

A:Arrays類概述

針對數(shù)組進(jìn)行操作的工具類。

提供了排序，查找等功能。

B:成員方法

public static String toString(int[] a)

public static void sort(int[] a)

public static int binarySearch(int[] a,int key)

import java.util.Arrays;
public class Array_4 {
    public static void main(String[] args) {
        int[] arr = {33,22,11,44,55,66,99,77};
        System.out.println(Arrays.toString(arr));//數(shù)組轉(zhuǎn)字符串
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));//排序
        int [] arr2 = {11,22,33,44,55,66,77,88,99};
        System.out.println(Arrays.binarySearch(arr2, 22));
        System.out.println(Arrays.binarySearch(arr2, 55));
        System.out.println(Arrays.binarySearch(arr2, 15));//負(fù)的插入點減一
    }
}

C:兩個方法分析

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

        StringBuilder b = new StringBuilder();        //線程不安全,效率高
        b.append("[");                                //將[添加到字符串緩沖區(qū)中
        for (int i = 0; ; i++) {                    //遍歷數(shù)組,判斷語句沒有寫默認(rèn)是true
            b.append(a[i]);                            //把第一個元素添加進(jìn)字符串緩沖區(qū)
            if (i == iMax)                            //如果索引等于了最大索引值
                return b.append("]").toString();    //將]添加到字符串緩沖區(qū),再轉(zhuǎn)換成字符串并返回
            b.append(", ");                            //如果不等于最大索引就將", "添加到緩沖區(qū)
        }
    }

    public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }

    private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
        int low = fromIndex;                //最小索引0
        int high = toIndex - 1;                //最大索引數(shù)組長度-1
        while (low <= high) {                //最小索引小于等于最大索引可以循環(huán)判斷
            int mid = (low + high) >>> 1;    //求出中間索引值,(最小+最大)/2
            int midVal = a[mid];            //通過中間索引獲取中間值

            if (midVal < key)                //中間索引對應(yīng)的值小于查找的值
                low = mid + 1;                //最小索引變化
            else if (midVal > key)            //中間索引對應(yīng)的值大于查找的值
                high = mid - 1;                //最大索引變化
            else
                return mid; // key found    //既不大也不小:找到了
        }
        return -(low + 1);  // key not found.//-插入點 - 1
    }

16_基本類型包裝類的概述

A:為什么會有基本類型包裝類

將基本數(shù)據(jù)類型封裝成對象的好處在于可以在對象中定義更多的功能方法操作該數(shù)據(jù)。

B:常用操作

常用的操作之一：用于基本數(shù)據(jù)類型與字符串之間的轉(zhuǎn)換。

C:基本類型和包裝類的對應(yīng)

byte             Byte
short            Short
int              Integer
long             Long
float            Float
double           Double
char             Character
boolean          Boolean

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

17_Integer類的概述和構(gòu)造方法

A:Integer類概述

通過JDK提供的API，查看Integer類的說明

Integer 類在對象中包裝了一個基本類型 int 的值,

該類提供了多個方法，能在 int 類型和 String 類型之間互相轉(zhuǎn)換，

還提供了處理 int 類型時非常有用的其他一些常量和方法

B:構(gòu)造方法

public Integer(int value)

public Integer(String s)

C:案例演示

使用構(gòu)造方法創(chuàng)建對象

    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        
        Integer i1 = new Integer(100);
        System.out.println(i1);
        
        Integer i2 = new Integer("abc");//java.lang.NumberFormatException數(shù)字格式異常
        System.out.println(i2);            //因為abc不是數(shù)字字符串，所以會報錯。
    }

18_String和int類型的相互轉(zhuǎn)換

A:int -- String

a:和""進(jìn)行拼接

b:public static String valueOf(int i)

c:int -- Integer -- String(Integer類的toString方法())

d:public static String toString(int i)(Integer類的靜態(tài)方法)

B:String -- int

a:String -- Integer -- int

int intValue() 以 int 類型返回該 Integer 的值。

public static int parseInt(String s)

基本數(shù)據(jù)類型包裝類有八種,其中七種都有parseXxx的方法,可以將這七種的字符串表現(xiàn)形式轉(zhuǎn)換成基本數(shù)據(jù)類型*

public class Wrap_3 {
    private static String s;
    public static void main(String[] args) {
//        demo1();
        String s = "true";
        boolean b = Boolean.parseBoolean(s);
        System.out.println(b);
        
//        String s2 = "abc";
//        char c = Character.        //char的包裝類Character中沒有pareseXxx的方法：char c 只能接收一個字符
                                //字符串到字符的轉(zhuǎn)換通過toCharArray()就可以把字符串轉(zhuǎn)換為字符數(shù)組
    }
    private static void demo1() {
        //int轉(zhuǎn)換成String
        int i = 100;
        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);
        System.out.println(s2);
        
        //String轉(zhuǎn)換成int
        String s = "200";
        Integer i3 = new Integer(s);
        int i4 = i3.intValue();            //將Integer轉(zhuǎn)換成了int    
        int i5 = Integer.parseInt(s);    //將String轉(zhuǎn)換為int,推薦用這種
    }
}

19_JDK5的新特性自動裝箱和拆箱

A:JDK5的新特性

自動裝箱：把基本類型轉(zhuǎn)換為包裝類類型

自動拆箱：把包裝類類型轉(zhuǎn)換為基本類型

B:案例演示

JDK5的新特性自動裝箱和拆箱

int x = 100;
Integer i1 = new Integer(x);        //將基本數(shù)據(jù)類型包裝成對象:裝箱
int y = i1.intValue();                //將對象轉(zhuǎn)換為基本數(shù)據(jù)類型:拆箱

Integer i2 = 100;                        //自動裝箱,把基本數(shù)據(jù)類型轉(zhuǎn)換成對象
int z = i2 + 200;                        //自動拆箱,把對象轉(zhuǎn)換為基本數(shù)據(jù)類型
System.out.println(z);

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

C:注意事項

在使用時，Integer x = null;代碼就會出現(xiàn)NullPointerException。

建議先判斷是否為null，然后再使用。

public class Wrap_JDK5_4 {
    public static void main(String[] args) {
        int x = 100;
        Integer i1 = new Integer(x);        //將基本數(shù)據(jù)類型包裝成對象，手動裝箱
        int y = i1.intValue();                //將對象轉(zhuǎn)換成基本數(shù)據(jù)類型，拆箱
    
        Integer i2 = 100;                    //自動裝箱，把基本數(shù)據(jù)類型轉(zhuǎn)換成對象
        int z = i2 + 200;                    //自動拆箱，把對象轉(zhuǎn)換為基本數(shù)據(jù)類型
        System.out.println(z);
        
        Integer i3 = 50;
        int a = i3 + 100;                    //底層用i3調(diào)用intValue,但是i3是null，出現(xiàn)空指針異常
        System.out.println(a);
    }
}

20_Integer的面試題

A:Integer的面試題-看程序?qū)懡Y(jié)果

public class Wrap_Integer_5 {
    public static void main(String[] args) {
        Integer i1 = new Integer(97);
        Integer i2 = new Integer(97);
        System.out.println(i1 == i2);//false
        System.out.println(i1.equals(i2));//true
        System.out.println("-----------");
    
        Integer i3 = new Integer(197);
        Integer i4 = new Integer(197);
        System.out.println(i3 == i4);//false
        System.out.println(i3.equals(i4));//true
        System.out.println("-----------");
    
        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);//true
        System.out.println(i5.equals(i6));//true
        System.out.println("-----------");
    
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);//false
        System.out.println(i7.equals(i8));//true

        /*
         * -128到127是byte的取值范圍,如果在這個取值范圍內(nèi),自動裝箱就不會新創(chuàng)建對象,而是從常量池中獲取
         * 如果超過了byte取值范圍就會再新創(chuàng)建對象
         * 
         * public static Integer valueOf(int i) {
                if (i >= IntegerCache.low && i <= IntegerCache.high)    //i>= -128 && i <= 127
                    return IntegerCache.cache[i + (-IntegerCache.low)]; //[索引:0-255] 如果傳入127,索引就變成127+(-(-128)),即最大索引255
                else {
                     return new Integer(i);    
                }
            }
         */
    }
}

GPU云服務(wù)器云服務(wù)器 java?14-&ampamp java輸出數(shù)組&039&039 java繼承類&amplt 服務(wù)器&amp存儲基礎(chǔ)

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/77128.html

發(fā)表評論

登陸后可評論

0條評論

banana_pi

男|高級講師

我要關(guān)注我要私信

TA的文章

云計算廠商迎來升級拐點，邊緣計算布局或?qū)⒊蓻Q勝點

閱讀 3595·2021-11-24 10:19
【操作系統(tǒng)】—I/O設(shè)備的基本概念和分類

閱讀 3733·2021-09-30 09:47
開源一個代碼畫板工具

閱讀 1300·2019-08-30 15:56
XBlog： Vue+Express+Mongodb的全棧可擴(kuò)展的完整博客系統(tǒng)

閱讀 798·2019-08-29 15:11
簡單說一道JS閉包面試題

閱讀 909·2019-08-29 13:43
JavaScript的作用域和塊級作用域概念理解

閱讀 3573·2019-08-28 18:25
Web技術(shù)的前世今生（一）

閱讀 2166·2019-08-26 13:27
JavaScript設(shè)計模式系列五：適配器模式

閱讀 1441·2019-08-26 11:44

成人国产在线小视频_日韩寡妇人妻调教在线播放_色成人www永久在线观看_2018国产精品久久_亚洲欧美高清在线30p_亚洲少妇综合一区_黄色在线播放国产_亚洲另类技巧小说校园_国产主播xx日韩_a级毛片在线免费

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

Java編程基礎(chǔ)14——常見對象_StringBuffer&數(shù)組排序&包裝類

相關(guān)文章

Java learn 03 常用類 & 容器 (待補充筆記)

Java編程基礎(chǔ)19——Map集合&斗地主案例

Java編程基礎(chǔ)12——Eclipse使用&Object類型

Java編程基礎(chǔ)34——JDBC&DBUtil

發(fā)表評論

0條評論

banana_pi

男|高級講師

TA的文章

云計算廠商迎來升級拐點，邊緣計算布局或?qū)⒊蓻Q勝點

【操作系統(tǒng)】—I/O設(shè)備的基本概念和分類

開源一個代碼畫板工具

XBlog： Vue+Express+Mongodb的全棧可擴(kuò)展的完整博客系統(tǒng)

簡單說一道JS閉包面試題

JavaScript的作用域和塊級作用域概念理解

Web技術(shù)的前世今生（一）

JavaScript設(shè)計模式系列五：適配器模式

最新活動

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

Java編程基礎(chǔ)14——常見對象_StringBuffer&數(shù)組排序&包裝類

相關(guān)文章

發(fā)表評論

0條評論

男|高級講師

TA的文章

最新活動

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！