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

     }

}