Java中基礎資料型別 (Elementary Data Type)和封裝類__Java

參考：深入剖析Java中的裝箱和拆箱;
Java中基礎資料型別 (Elementary Data Type)和封裝類互轉中 緩衝機制的使用 ;
java學習筆記:裝箱和拆箱,封裝器和緩衝池
Java 各 類型資料在記憶體中分配情況詳解 一 java記憶體配置

這裡只是在網上找的一些資料;
Java 中的資料類型分為
1. 基本類型（未經處理資料類型） byte short int long float double char boolean
基本類型的變數持有原始值。
2. 符合資料類型（參考型別），參考型別持有引用值（即對某個對象的引用，而非對象本身）。

一般Java在記憶體配置時會涉及到以下地區：
1. 寄存器：我們在程式中無法控制
2. 棧：存放基本類型的資料和對象的引用，但對象本身不存放在棧中，而是存放在堆中
3. 堆：存放用new產生的資料
4. 靜態域：存放在對象中用static定義的靜態成員
5. 常量池：存放常量
6. 非RAM儲存：硬碟等永久儲存空間
其中主要是堆，棧的儲存。 堆，棧

函數中定義的一些基本類型的資料變數和對象的引用變數都在函數的棧記憶體中分配。
棧的優勢是存取速度比堆要快，僅次於直接位於CPU 的寄存器，而且資料可以共用。但是存在棧中的資料大小與生存周期必須是確定的。
當在一段代碼塊定義一個變數時，Java就在棧中 為這個變數分配記憶體空間，當該變數退出該範圍後，Java會自動釋放掉為該變數所分配的記憶體空間，該記憶體空間可以立即被另作他用。

堆記憶體用來存放由new建立的對象和數組。 在堆中分配的記憶體，由Java虛擬機器的自動記憶體回收行程來管理。
在堆中產生了一個數組或對象後，還可以 在棧中定義一個特殊的變數，讓棧中這個變數的取值等於數組或對象在堆記憶體中的首地址，棧中的這個變數就成了數組或對象的引用變數。
引用變數是普通的變數，定義時在棧中分配，引用變數在程式運行到其範圍之外後被釋放。而數組和對象本身在堆中分配，即使程式 運行到使用 new 產生數組或者對象的語句所在的代碼塊之外，數組和對象本身佔據的記憶體不會被釋放，數組和對象在沒有引用變數指向它的時候，才變為垃圾，不能在被使用，但仍 然佔據記憶體空間不放，在隨後的一個不確定的時間被記憶體回收行程收走（釋放掉）。 二 基礎資料型別 (Elementary Data Type)

這種類型是通過諸如 int a=7; 的形式來定義的，稱為自動變數。這裡自動變數是字面值。不是類的執行個體，即不是類的引用，這裡並沒有類的存在。a 是指向一個 int 類型的引用，指向 7 這個字面值。由於其大小確定生存期可知（這些定義在某個程式塊中，程式塊退出後，欄位值就消失），因此存在棧中.
由於棧的資料可以共用，因此 int a=3; int b=3; 這段代碼，編譯器首先處理 int a =3; ,先會在棧中建立一個變數為 a 的引用，然後尋找有沒有字面值為 3的地址，沒有找到，就開闢一個存放 3 這個字面值的地址，然後將a 指向 3 的地址。接下來處理int b =3; 在建立完 b 這個引用變數後，由於棧中已經有 3 這個字面值，便將 b 指向 3 的地址。【定義變數，給變數賦值】 三 封裝類資料

Java中的基本類型不是物件導向的，它們只是純粹的資料，除了數值本身的資訊之外，基本類型資料不帶有其他資訊或者可操作方法。這在實際使用中存在很多不足，為瞭解決這個不足，* 對每個基本類型都對應了一個引用的類型*，稱為裝箱基本類型。
1，拆箱，裝箱

裝箱：根據資料建立對應的封裝對象。

Integer i = new Integer (3);Integer j = 4;//jdk1.5 之後可以通過這種方式自動裝箱

拆箱：將封裝類型轉換為基礎資料型別 (Elementary Data Type)。

int  index2 = j.intValue();int  index1 = i;//自動拆箱

JDK1.5 為Integer 增加了一個全新的方法：public static Integer valueOf(int i) 在自動裝箱過程時，編譯器調用的是static Integer valueOf(int i)這個方法 於是Integer a=3; ==> Integer a=Integer.valueOf(3);。

此方法與new Integer(i)的不同處在於:
方法一調用類方法返回一個表示 指定的 int 值的 Integer 執行個體。方法二產生一個新的Integer 對象。

2，緩衝機制

JDK API文檔中對這個新的valueOf方法有明確的解釋：
如果不需要新的 Integer 執行個體，則通常應優先使用該方法，而不是構造方法 Integer(int)，因為該方法有可能通過緩衝經常請求的值而顯著提高空間和時間效能 .

查看Integer的valueOf方法的：

    public static Integer valueOf(int i) {        assert IntegerCache.high >= 127;        //static final int low = -128;        //當-128=<i<=127的時候，就直接在緩衝中取出 i de  Integer 類型對象        if (i >= IntegerCache.low && i <= IntegerCache.high)            return IntegerCache.cache[i + (-IntegerCache.low)];        //否則就在堆記憶體中建立        return new Integer(i);    }

看出對於範圍 [-128,127] 的整數，valueOf 方法做了特殊處理。採用IntegerCache.cache[i + (-IntegerCache.low)]; 這個方法。

查看 IntegerCache 類的實現為：

    private static class IntegerCache {        static final int low = -128; //最小值是固定的        static final int high;        static final Integer cache[];//cache 緩衝是一個存放Integer類型的數組        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) {                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);            }            high = h;            cache = new Integer[(high - low) + 1];  //初始化數組            int j = low;            //緩衝區間資料            for(int k = 0; k < cache.length; k++)            //將-128~127封裝成256個對象存入緩衝                cache[k] = new Integer(j++);        }        private IntegerCache() {}    }

IntegerCache初始化後記憶體中就有Integer緩衝區cache[]了，-128~127區間的int值有其對應的的封裝對象。這就是 valueOf 方法真正的最佳化方法，當-128=

public class ZhuangXaing {    public static void main(String[] args) {        Integer i= new Integer(12);        Integer j=12;        Integer k=Integer.valueOf(12);        Integer l= new Integer(232);        Integer m=232;        Integer n=232;        Double  q = 232.0;        System.out.println("use ==.......");            System.out.println(i==12);        System.out.println(i==j);        System.out.println(j==k);        System.out.println(l==232);        System.out.println(l==m);        System.out.println(m==n);        System.out.println("use equals.....");        System.out.println(m.equals(n));        System.out.println(m.equals(q));    }}

輸出結果:

use ==.......truefalsetruetruefalsefalseuse equals.....truefalse

Integer i= new Integer(12); 是指明了在堆記憶體中建立對象；
Integer j=12; 是自動裝箱，調用valueOf 方法，返回return IntegerCache.cache[12 + 128]， 得到的是Integer 緩衝池中的對象。 Integer k=Integer.valueOf(12); 與Integer j=12; 本質上相同，指向緩衝池中同一對象。封裝對象與數值比較，自動拆箱。
而對於大於127 的數值，執行的都是return new Integer(i) 都在堆記憶體中，但是地址不同。

對於equals 方法比較的是數值大小：

public boolean equals(Object obj) {        if (obj instanceof Integer) {            return value == ((Integer)obj).intValue();        }        return false;    }

可以看出比較的 obj 如果是 Integer 的執行個體，則比較拆箱後數值的是否相等。否則返回false。

2，下面這段代碼輸出結果是什麼：

public class Main {    public static void main(String[] args) {        Double i1 = 100.0;        Double i2 = 100.0;        Double i3 = 200.0;        Double i4 = 200.0;        System.out.println(i1==i2);        System.out.println(i3==i4);    }//false//false

因為Double類的valueOf方法會採用與Integer類的valueOf方法不同的實現。很簡單：在某個範圍內的整型數值的個數是有限的，而浮點數卻不是。

其他的封裝器:
Boolean： (全部緩衝)
Byte： (全部緩衝)

Character ( <=127 緩衝)
Short (-128~127 緩衝)
Long (-128~127 緩衝)

Float (沒有緩衝)
Doulbe (沒有緩衝)

3，下面這段代碼輸出結果是什麼：

public class Main {    public static void main(String[] args) {        Boolean i1 = false;        Boolean i2 = false;        Boolean i3 = true;        Boolean i4 = true;        System.out.println(i1==i2);        System.out.println(i3==i4);    }}

先看Boolean 類的源碼 ，valueOf 方法的實現：

public static Boolean valueOf(boolean b) {        return (b ? TRUE : FALSE);    }

而其中的 TRUE 和FALSE又是什麼呢。在Boolean中定義了2個靜態成員屬性：

public static final Boolean TRUE = new Boolean(true);    /**      * The <code>Boolean</code> object corresponding to the primitive      * value <code>false</code>.      */    public static final Boolean FALSE = new Boolean(false);

由此可知上面代碼輸出都為true .