Java工具類——包裝類

我們都知道，JDK 其實給我們提供了很多很多 Java 開發者已經寫好的現成的類，他們其實都可以理解成工具類，比如我們常見的集合類，日期相關的類，數學相關的類等等，有了這些工具類，你會發現它能很大程度的幫你節省時間，能很方便的實現你的需求。當然，沒有這些包，你也能實現你的需求，但是你需要時間，今天我們主要是來學習一下包裝類。

一、包裝類介紹

1、為什麼需要包裝類？

我們知道 Java 語言是一個面向對象的編程語言，但是 Java 中的基本數據類型卻不是面向對象的，但是我們在實際使用中經常需要將基本數據類型轉換成對象，便於操作，比如，集合的操作中，這時，我們就需要將基本類型數據轉化成對象，所以就出現了包裝類。

2、包裝類是什麼呢？

包裝類，顧名思義就是將什麼經過包裝的類，那麼是將什麼包裝起來的呢，顯然這裡是將基本類型包裝起來的類。包裝類的作用就是將基本類型轉成對象，將基本類型作為對象來處理。

Java 中我們知道，基本數據類型有8個，所以對應的包裝類也是8個，包裝類就是基本類型名稱首字母大寫。但Integer 和 Character 例外，它們显示全稱，如下面表格所示：

二、包裝類的繼承關係

通過閱讀 Java8 的 API 官方文檔或者看源代碼我們可以得知8個包裝類的繼承關係如下：

通過以上的繼承關係圖，我們其實可以這樣記憶，包裝類裏面有6個與数字相關的都是繼承自 Number 類，而其餘兩個不是與数字相關的都是默認繼承 Object 類。通過看 API 官方文檔，我們還可以得知這8個包裝類都實現了Serializable , Comparable 接口。比如下圖的 Integer 類

public final class Integer extends Number implements Comparable<Integer> {}

三、包裝類的使用方法（基本操作）

接下來關於包裝類的講解我就講Integer包裝類，其他的都依此類推，用法和操作都是差不多的，只是名字不一樣而已。

1、包裝類的構造方法

8個包裝類都有帶自己對應類型參數的構造方法，其中8個包裝類中除了Character還有構造方法重載，參數是String類型的。

Integer one = new Integer(666);
Integer two = new Integer("666");

2、包裝類的自動拆裝箱

在了解自動拆裝箱之前，我們得先知道什麼是拆箱和裝箱。其實拆裝箱主要應對基本類型與包裝類型的相互轉換問題。

• 裝箱：將基本類型轉換成包裝類型的過程叫做裝箱。

• 拆箱：將包裝類型轉換成基本類型的過程叫做拆箱。

其實，在 JDK1.5 版本之前，是沒有自動拆裝箱的，開發人員要手動進行裝拆箱：

//手動裝箱，也就是將基本類型10轉換為引用類型
Integer integer = new Integer(10);
//或者
Integer integer1 = Integer.valueOf(10);

//手動拆箱，也就是將引用類型轉換為基本類型
int num = integer.intValue();

而在在 JDK1.5 版本之後，為了減少開發人員的工作，提供了自動裝箱與自動拆箱的功能。實現了自動拆箱和自動裝箱，如下方代碼所示：

//自動裝箱
Integer one = 1;
//自動拆箱
int two = one + 10;

其實以上兩種方式本質上是一樣得，只不過一個是自動實現了，一個是手動實現了。至於自動拆裝箱具體怎麼實現的我這裏不做深入研究。

四、包裝類的緩存機制

我們首先來看看以下代碼，例1：

public static void main(String[] args) {
  Integer i1 = 100;
  Integer i2 = 100;
  Integer i3 = new Integer(100);
  Integer i4 = new Integer(100);
  System.out.println(i1 == i2);//true
  System.out.println(i1 == i3);//false
  System.out.println(i3 == i4);//false
  System.out.println(i1.equals(i2));//true
  System.out.println(i1.equals(i3));//true
  System.out.println(i3.equals(i4));//true
}

當我們修改了值為200的時候，例2：

public static void main(String[] args) {
  Integer i1 = 200;
  Integer i2 = 200;
  Integer i3 = new Integer(200);
  Integer i4 = new Integer(200);
  System.out.println(i1 == i2);//false
  System.out.println(i1 == i3);//false
  System.out.println(i3 == i4);//false
  System.out.println(i1.equals(i2));//true
  System.out.println(i1.equals(i3));//true
  System.out.println(i3.equals(i4));//true
}

通過上面兩端代碼，我們發現修改了值，第5行代碼的執行結果竟然發生了改變，為什麼呢？首先，我們需要明確第1行和第2行代碼實際上是實現了自動裝箱的過程，也就是自動實現了 Integer.valueOf 方法，其次，比較的是地址，而 equals 比較的是值（這裏的 eauals 重寫了，所以比較的是具體的值），所以顯然最後五行代碼的執行結果沒有什麼疑惑的。既然比較的是地址，例1的第5行代碼為什麼會是true呢，這就需要我們去了解包裝類的緩存機制。

其實看Integer類的源碼我們可以發現在第780行有一個私有的靜態內部類，如下：

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

我們知道，靜態的內部類是在整個 Integer 加載的時候就已經加載完成了，以上代碼初始化了一個 Integer 類型的叫 cache 的數組，取值範圍是[-128, 127]。緩存機制的作用就是提前實例化相應範圍數值的包裝類對象，只要創建處於緩存範圍的對象，就使用已實例好的對象。從而避免重複創建多個相同的包裝類對象，提高了使用效率。如果我們用的對象範圍在[-128, 127]之內，就直接去靜態區找對應的對象，如果用的對象的範圍超過了這個範圍，會幫我們創建一個新的 Integer 對象，其實下面的源代碼就是這個意思：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

所以 例1 代碼里，i1 和i2 是100，值的範圍在[-128, 127]，所以直接區靜態區找，所以i1和i2指向的地址是同一個，所以 i1==i2；而在例2的代碼里，i1 和i2 是200，值的範圍不在在[-128, 127]，所以分別創建了一個新的對象，放在了堆內存里，各自指向了不同的地址，所以地址都不同了，自然 i1 不等於 i2。

通過分析源碼我們可以發現，只有 double 和 float 的自動裝箱代碼沒有使用緩存，每次都是 new 新的對象，其它的6種基本類型都使用了緩存策略。
使用緩存策略是因為，緩存的這些對象都是經常使用到的（如字符、-128至127之間的数字），防止每次自動裝箱都創建一次對象的實例。

五、包裝類和基本數據類型的區別

• 默認值不同

包裝類的默認值是null，而基本數據類型是對應的默認值（比如整型默認值是0，浮點型默認值是0.0）

• 存儲區域不同

基本數據類型是把值保存在棧內存里，包裝類是把對象放在堆中，然後通過對象的引用來調用他們

• 傳遞方式不同

基本數據類型變量空間裏面存儲的是值，傳遞的也是值，一個改變，另外一個不變，而包裝類屬於引用數據類型，變量空間存儲的是地址(引用)，傳遞的也是引用，一個變，另外一個跟着變。

五、小結

​ 以上就是我對於Java包裝類的個人理解，其實學習這些工具類還有一個更好的學習方式，就是去看官方文檔（API官方文檔地址：https://docs.oracle.com/javase/8/docs/api/）

公眾號：良許Linux

有收穫？希望老鐵們來個三連擊，給更多的人看到這篇文章

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※教你寫出一流的銷售文案?

一、概述

先放百科上的說法：

算法的時間複雜度（Time complexity）是一個函數，它定性描述該算法的運行時間。這是一個代表算法輸入值的字符串的長度的函數。

時間複雜度常用大O符號表述，不包括這個函數的低階項和首項係數。使用這種方式時，時間複雜度可被稱為是漸近的，亦即考察輸入值大小趨近無窮時的情況。

例如，如果一個算法對於任何大小為 n （必須比 n0 大）的輸入，它至多需要 5n3 + 3n 的時間運行完畢，那麼它的漸近時間複雜度是 O(n3).

二、時間頻度

要理解時間複雜度，需要先理解時間頻度，而時間頻度簡單的說，就是算法中語句的執行次數。

舉個例子：

要計算1+2+…+100，現在有兩種算法

public int fun1(int n){
    int total;
    for(int i = 0; i <= n; i++){
        total+=i;
    }
    return total;
}

public int fun2(int n){
    int total = (1 + n)*n/2;
    return total;
}

我們可以看見，對於fun1()這個方法，不管n多大，永遠需要執行n+1次，也就是說他的時間頻度是T(n)=n+1,

而對與fun2()來說，不管n多大都只需要執行1次，所以他的時間頻度T(n)=1。

當n趨向無窮大時，有三個忽略：

1.忽略常數項

比如T(n)=2n+1，當n趨向無窮大時，可以忽略常數項1；

參見下圖：

• 2n+20 和 2n 隨着n 變大，執行曲線無限接近, 20可以忽略
• 3n+10 和 3n 隨着n 變大，執行曲線無限接近, 10可以忽略

2.忽略低次項

比如T(n)=2n+3n^8，當n趨向無窮大時，可以忽略低次項及其係數2n；

參見下圖：

• 2n^2+3n+10 和 2n^2 隨着n 變大, 執行曲線無限接近, 可以忽略 3n+10
• n^2+5n+20 和 n^2 隨着n 變大,執行曲線無限接近, 可以忽略 5n+20

3.忽略係數

比如T(n)=2n^8，當n趨向無窮大時，可以忽略係數2。

參見下圖：

• 隨着n值變大，5n^2+7n 和 3n^2 + 2n ，執行曲線重合, 說明 這種情況下, 5和3可以忽略。
• 而n^3+5n 和 6n^3+4n ，執行曲線分離，說明多少次方式關鍵

三、時間複雜度

我們現在理解了時間頻度的T(n)的含義，假設當有一個輔助函數f(n)，使得當n趨近無窮大時，T(n)/f(n)的極限值為不等於0的常數，就叫f(n)為T(n)的同量級函數，記作T(n)=O(f(n))，

稱O(f(n))為算法的時間漸進複雜度，也就是時間複雜度。

又根據時間頻度T(n)的“三個忽略”原則，我們可以知道時間複雜度是這樣得到的：

1. 忽略所有常數
2. 只保留函數中的最高階項
3. 去掉最高階項的係數

舉個例子：

某算法T(n)=2n^3+4n-5，按步驟走：

1. T(n)=2n^3+4n
2. T(n)=2n^3
3. T(n)=n^3

即可得該算法時間複雜度為O(n^3)

四、常見時間複雜度

這裏按複雜度從低到高列舉常見的時間複雜度：

1. 常數階O(1)

   // 無論代碼執行了多少行，只要是沒有循環等複雜結構，那這個代碼的時間複雜度就都是O(1) 。
   public void fun(int n){
       n+=1;
   }
   

2. 對數階O(log2n)

   // 根據公式有 n = 2^x，也就是 x = log2n，x即為循環代碼執行次數，所以時間複雜度為O(log2n)
   public void fun(int n){
       int i = 1;
       while(i < n){
           i = i *2
       }
   }
   

3. 線性階O(n)

   // 一般來說，只要代碼里只有一個循環結構，即輸入規模和執行次數呈線性相關，那這個代碼的時間複雜度就都是O(n) 。
   public void fun(int n){
       for(int i = 0; i < n; i++){
           n+=i;
       }
   }
   

4. 線性對數階O(nlogn)

   // 可以簡單理解為對數階的程序被放入了循環結構中，也就是n*O(logn)，下面的代碼的複雜度就是O(nlog2n)
   public void fun(int n){
       int j = 1;
       for(int i = 0; i < n; i++){
           while(i < n){
               j = j *2
           }
       }
   }
   

5. 平方階O(n²)，立方階O(n^{3)，K次方階O(n}k)

   // 平方階可以簡單理解為線性階中嵌套一個線性階，也就是O(logn)*O(logn)，下面的代碼複雜度就是O(n^2)
   // 立方階同理，就是三個線性階的嵌套，K次方階同理
   public void fun(int n){
       for(int i = 0; i < n; i++){
           for(int j = 0; j < n; i++){
   			i=i+j;
           } 
       }
   }
   

五、複雜度的四個概念

1. 最壞情況時間複雜度：代碼在最理想情況下執行的時間複雜度。
2. 最好情況時間複雜度：代碼在最壞情況下執行的時間複雜度。
3. 平均時間複雜度：用代碼在所有情況下執行的次數的加權平均值表示
4. 均攤時間複雜度：在代碼執行的所有複雜度情況中絕大部分是低級別的複雜度，個別情況是高級別複雜度且發生具有時序關係時，可以將個別高級別複雜度均攤到低級別複雜度上。基本上均攤結果就等於低級別複雜度。

舉個例子：

長度為n的數組查找一個給定元素k

public void fun(int[] arr,int k){
    for(int i = 0; i < arr.length; i++){
        if(arr[i] == k){
            //找到了
        }
    }
}

上面這個方法，最好的情況下元素k就在數組第一位，複雜度為O(1)，但是最壞的情況下，元素k在數組最後一位，複雜度為O(n)。

同一段代碼在不同情況下時間複雜度會出現量級差異，為了更全面，更準確的描述代碼的時間複雜度，我們引入這4個概念，當然，在大多數時候我們是不用特意區分這四種情況的。

六、總結

總結一下如何快速判斷程序的時間複雜度：

• 只關注循環最多的那部分代碼
• 總複雜度等於量級最大的那段代碼的複雜度
• 嵌套代碼的複雜度等於嵌套內外代碼複雜度的乘積

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※教你寫出一流的銷售文案?