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("包装类型参数的方法被调用");
    }
}