public static void main(String[]args){

    Listlist=new ArrayList；

    list.add(1)；

    list.add(2)；

    list.add(null)；

    System.out.println(f(list))；

    }

    把1、2和空值都放到List中，然后调用方法计算，现在来思考一下

    会不会出错。应该不会出错吧，基本类型和包装类型都是可以通过自动

    装箱(Autoboxing)和自动拆箱(AutoUnboxing)自由转换的，null应

    该可以转为0吧，真的是这样吗？我们运行一下看看结果：

    Exception in threadmainjava.lang.NullPointerException

    运行失败，报空指针异常，我们稍稍思考一下很快就知道原因了：

    在程序的for循环中，隐含了一个拆箱过程，在此过程中包装类型转换为

    了基本类型。我们知道拆箱过程是通过调用包装对象的intValue方法来

    实现的，由于包装对象是null值，访问其intValue方法报空指针异常也就在所难免了。问题清楚了，修改也很简单，加入null值检查即可，代码

    如下：

    public static int f(Listlist){

    int count=0；

    for(Integer i：list){

    count+=(i!=null)?i：0；

    }

    return count；

    }

    上面以Integer和int为例说明了拆箱问题，其他7个包装对象的拆箱

    过程也存在着同样的问题。包装对象和拆箱对象可以自由转换，这不

    假，但是要剔除null值，null值并不能转化为基本类型。对于此类问题，我们谨记一点：包装类型参与运算时，要做null值校验。建议27：谨慎包装类型的大小比较

    基本类型是可以比较大小的，其所对应的包装类型都实现了

    Comparable接口也说明了此问题，那我们来比较一下两个包装类型的大

    小，代码如下：

    public class Client{

    public static void main(String[]args){

    Integer i=new Integer(100)；

    Integer j=new Integer(100)；

    compare(i, j)；

    }

    比较两个包装对象大小

    public static void compare(Integer i, Integer j){

    System.out.println(i==j)；

    System.out.println(i>j)；

    System.out.println(i
    }

    }

    代码很简单，产生了两个Integer对象，然后比较两者的大小关系，既然基本类型和包装类型是可以自由转换的，那上面的代码是不是就可

    打印出两个相等的值呢？让事实说话，运行结果如下：

    false

    false

    false

    竟然是3个false，也就是说两个值之间不等，也没大小关系，这也

    太奇怪了吧。不奇怪，我们来一一解释。

    i==j

    在Java中“==”是用来判断两个操作数是否有相等关系的，如果是基

    本类型则判断值是否相等，如果是对象则判断是否是一个对象的两个引

    用，也就是地址是否相等，这里很明显是两个对象，两个地址，不可能

    相等。

    i>j和i”和“<”用来判断两个数字类型的大小关系，注意只

    能是数字型的判断，对于Integer包装类型，是根据其intValue方法

    的返回值(也就是其相应的基本类型)进行比较的(其他包装类型是根

    据相应的value值来比较的，如doubleValue、floatValue等)，那很显

    然，两者不可能有大小关系的。

    问题清楚了，修改总是比较容易的，直接使用Integer实例的

    compareTo方法即可。但是这类问题的产生更应该说是习惯问题，只要

    是两个对象之间的比较就应该采用相应的方法，而不是通过Java的默认

    机制来处理，除非你确定对此非常了解。建议28：优先使用整型池

    上一建议我们解释了包装对象的比较问题，本建议将继续深入讨论

    相关问题，首先看如下代码：

    public static void main(String[]args){

    Scanner input=new Scanner(System.in)；

    while(input.hasNextInt){

    int ii=input.nextInt；

    System.out.println(\n====+ii+的相等判断======)；

    两个通过new产生的Integer对象

    Integer i=new Integer(ii)；

    Integer j=new Integer(ii)；

    System.out.println(new产生的对象：+(i==j))；

    基本类型转为包装类型后比较

    i=ii；

    j=ii；

    System.out.println(基本类型转换的对象：+(i==j))；

    通过静态方法生成一个实例

    i=Integer.valueOf(ii)；

    j=Integer.valueOf(ii)；

    System.out.println(valueOf产生的对象：+(i==j))；

    }

    }

    输入多个数字，然后按照3种不同的方式产生Integer对象，判断其

    是否相等，注意这里使用了“==”，这说明判断的不是同一个对象。我们

    输入三个数字127、128、555，结果如下：

    ====127的相等判断======

    new产生的对象：false

    基本类型转换的对象：true

    valueOf产生的对象：true

    ====128的相等判断======

    new产生的对象：false

    基本类型转换的对象：false

    valueOf产生的对象：false

    ====555的相等判断======

    new产生的对象：false

    基本类型转换的对象：false

    valueOf产生的对象：false

    很不可思议呀，数字127的比较结果竟然与其他两个数字不同，它

    的装箱动作所产生的对象竟然是同一个对象，valueOf产生的也是同一

    个对象，但是大于127的数字128和555在比较过程中所产生的却不是同

    一个对象，这是为什么？我们一个一个来解释。(1)new产生的Integer对象

    new声明的就是要生成一个新的对象，没二话，这是两个对象，地

    址肯定不等，比较结果为false。

    (2)装箱生成的对象

    对于这一点，首先要说明的是装箱动作是通过valueOf方法实现

    的，也就是说后两个算法是相同的，那结果肯定也是一样的，现在的问

    题是：valueOf是如何生成对象的呢？我们来阅读一下Integer.valueOf的

    实现代码：

    public static Integer valueOf(int i){

    final int offset=128；

    if(i>=-128＆＆i<=127){must cache

    return IntegerCache.cache[i+offset]；

    }

    return new Integer(i)；

    }

    这段代码的意思已经很明了了，如果是-128到127之间的int类型转

    换为Integer对象，则直接从cache数组中获得，那cache数组里是什么东

    西，代码如下：

    static final Integer cache[]=new Integer[-(-128)+127+1]；

    static{

    for(int i=0；i
    cache[i]=new Integer(i-128)；

    }

    cache是IntegerCache内部类的一个静态数组，容纳的是-128到127之

    间的Integer对象。通过valueOf产生包装对象时，如果int参数在-128和

    127之间，则直接从整型池中获得对象，不在该范围的int类型则通过

    new生成包装对象。

    明白了这一点，要理解上面的输出结果就迎刃而解了，127的包装

    对象是直接从整型池中获得的，不管你输入多少次127这个数字，获得

    的对象都是同一个，那地址当然都是相等的。而128、555超出了整型池

    范围，是通过new产生一个新的对象，地址不同，当然也就不相等了。

    以上的解释也是整型池的原理，整型池的存在不仅仅提高了系统性能，同时也节约了内存空间，这也是我们使用整型池的原因，也就是在

    声明包装对象的时候使用valueOf生成，而不是通过构造函数来生成的

    原因。顺便提醒大家，在判断对象是否相等的时候，最好是用equals方

    法，避免用“==”产生非预期结果。

    注意 通过包装类的valueOf生成包装实例可以显著提高空间和时

    间性能。建议29：优先选择基本类型

    包装类型是一个类，它提供了诸如构造方法、类型转换、比较等非

    常实用的功能，而且在Java 5之后又实现了与基本类型之间的自动转

    换，这使包装类型如虎添翼，更是应用广泛了，在开发中包装类型已经

    随处可见，但无论是从安全性、性能方面来说，还是从稳定性方面来

    说，基本类型都是首选方案。我们来看一段代码：

    public class Client{

    public static void main(String[]args){

    Client cilent=new Client；

    int i=140；

    分别传递int类型和Integer类型

    cilent.f(i)；

    cilent.f(Integer.valueOf(i))；

    }

    public void f(long a){

    System.out.println(基本类型的方法被调用)；

    }

    public void f(Long a){

    System.out.println(包装类型的方法被调用)；

    }

    }

    在上面的程序中首先声明了一个int变量i，然后加宽转变成long型，再调用f方法，分别传递int和long的基本类型和包装类型，诸位想想

    该程序是否能够编译？如果能编译输出结果又是什么呢？

    首先，这段程序绝对是能够编译的。不过，说不能编译的同学还是

    很动了一番脑筋的，只是还欠缺点火候，你可能会猜测以下这些地方不

    能编译：

    f方法重载有问题。定义的两个f方法实现了重载，一个形

    参是基本类型，一个形参是包装类型，这类重载很正常。虽然基本类型

    和包装类型有自动装箱、自动拆箱的功能，但并不影响它们的重载，自

    动拆箱(装箱)只有在赋值时才会发生，和重载没有关系。

    cilent. f(i)报错。i是int类型，传递到fun(long l)是没有任何问

    题的，编译器会自动把i的类型加宽，并将其转变为long型，这是基本类

    型的转换规则，也没有任何问题。

    cilent. f(Integer.valueOf(i))报错。代码中没有f(Integer i ......