Java 包裝類型及易錯陷阱詳解

int i = 5;//直接在棧中分配空間
Integer i = new Integr(5);//對象是在堆內存中,而i(引用變量)是在棧內存中

Integer i = new Integer(20);
i = 50;
System.out.println(i); // 50

BigInteger fiveThousand = new BigInteger("5000");
BigInteger fiftyThousand = new BigInteger("50000");
BigInteger fiveHundredThousand = new BigInteger("500000");
BigInteger total = BigInteger.ZERO;
total = total.add(fiveThousand);
total = total.add(fiftyThousand);
total = total.add(fiveHundredThousand);
System.out.println(total);

//聲明一個Integer對象
Integer num = 10;
/*以上的聲明就是用到瞭自動的裝箱,解析為:
Integer num = new Integer(10);
以上就是一個很好的體現，因為10是屬於基本數據類型的，原則上它是不能直接賦值給一個對象Integer的，但jdk1.5後你就可以進行這樣的聲明，這就是自動裝箱的魅力,自動將基本數據類型轉化為對應的封裝類型。成為一個對象以後就可以調用對象所聲明的所有的方法
自動拆箱：故名思議就是將對象重新轉化為基本數據類型：*/
 
//裝箱
Integer num_1 = 10;
//拆箱
int num_2 = num_1;
/*自動拆箱有個很典型的用法就是在進行運算的時候：因為對象時不能直接進行運算的，而是要轉化為基本數據類型後才能進行加減乘除*/
 
Integer num_3 = 10;
//進行計算時隱含的有自動拆箱
System.out.print(num_3--);
/*哈哈 應該感覺很簡單吧，下面我再來講點稍微難點的.*/
 
//在-128~127 之外的數
Integer num_4 = 297; Integer num_5 = 297;
System.out.println("num_4==num_5: "+(num_4==num_5));
// 在-128~127 之內的數
Integer num_6 = 97; Integer num_7 = 97;
System.out.println("num_6==num_7: "+(num_6==num_7));
/*打印的結果是：
    num_4==num_5: false 
    num_6==num_7: true 
*/
//此處的解釋在下方

import java.util.ArrayList;
import java.util.List;
public class Ceshi {
    // 計算list中所有元素之和
    public static int f(List<Integer> list) {
        int count = 0;
        for (int i : list) {
            count += i;
        }
        return count;
    }
 
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(null);
        System.out.println(f(list));
    }
}

// 計算list中所有元素之和
public static int f(List<Integer> list) {
    int count = 0;
    for (Integer i : list) {
        count += (null != i) ? i : 0;
    }
    return count;
}

@SuppressWarnings("resource")
Scanner input = new Scanner(System.in);
while (input.hasNextInt()) {
    int i = input.nextInt();
    System.out.println("\n*********" + i + "的相等判斷**********");
    // 兩個通過new產生的integer對象
    Integer temp1 = new Integer(i);
    Integer temp2 = new Integer(i);
    System.out.println("new產生的對象：" + (temp1 == temp2));
 
    // 基本類型轉為包裝類型後比較
    temp1 = i;
    temp2 = i;
    System.out.println("基本類型轉換的對象：" + (temp1 == temp2));
 
    // 通過靜態方法生成一個實例
    temp1 = Integer.valueOf(i);
    temp2 = Integer.valueOf(i);
    System.out.println("valueOf產生的對象：" + (temp1 == temp2));
}

/***
 * Cache to support the object identity semantics of autoboxing for values
 * between*-128 and 127(inclusive)as required by JLS.**The cache is initialized
 * on first usage.The size of the cache*may be controlled by the{
 * 
 * @code -XX:AutoBoxCacheMax=<size>}option.*During VM
 *       initialization,java.lang.Integer.IntegerCache.high property*may be set
 *       and saved in the private system properties in the*sun.misc.VM class.
 */
 
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() {
	}
 
}
 
/**
* Returns an {@code Integer} instance representing the specified
* {@code int} value. If a new {@code Integer} instance is not
* required, this method should generally be used in preference to
* the constructor {@link #Integer(int)}, as this method is likely
* to yield significantly better space and time performance by
* caching frequently requested values.
*
* This method will always cache values in the range -128 to 127,
* inclusive, and may cache other values outside of this range.
*
* @param i an {@code int} value.
* @return an {@code Integer} instance representing {@code i}.
* @since 1.5
*/
public static Integer valueOf(int i) {
	if (i >= IntegerCache.low && i <= IntegerCache.high)
		return IntegerCache.cache[i + (-IntegerCache.low)];
	return new Integer(i);
}

public class Ceshi {
    public static void main(String[] args) {
        Ceshi temp=new Ceshi();
        int a=500;
        //分別傳遞int類型和Integer類型
        temp.f(a);
        temp.f(Integer.valueOf(a));
    }
    public void f(long i){
        System.out.println("基本類型參數的方法被調用");
    }
    public void f(Long i){
        System.out.println("包裝類型參數的方法被調用");
    }
}

temp.f(Integer.valueOf(a));

public class Ceshi {
    public static void main(String[] args) {
        Ceshi temp=new Ceshi();
        int a=500;
        //分別傳遞int類型和Long類型
        temp.f(a);
        temp.f(Long.valueOf(a));
    }
    public void f(long i){
        System.out.println("基本類型參數的方法被調用");
    }
    public void f(Long i){
        System.out.println("包裝類型參數的方法被調用");
    }
}