优先使用整形池

  1. public static void main(String[] args) {  
  2.      Scanner input = new Scanner(System.in);  
  3.      while(input.hasNextInt()){  
  4.           int ii = input.nextInt();  
  5.           System.out.println("\n===="+ii+" 的相等判断======");  
  6.           //两个通过new产生的Integer对象  
  7.           Integer i =new Integer(ii);  
  8.           Integer j = new Integer(ii);  
  9.           System.out.println("new产生的对象：" + (i==j));  
  10.  
  11.           //基本类型转为包装类型后比较  
  12.           i=ii;  
  13.           j=ii;  
  14.           System.out.println("基本类型转换的对象：" + (i==j));  
  15.  
  16.           //通过静态方法生成一个实例  
  17.           i=Integer.valueOf(ii);  
  18.           j = Integer.valueOf(ii);  
  19.           System.out.println("valueOf产生的对象："  + (i==j));  
  20.      }  
  21. } 

 

输入多个数字，然后按照3种不同的方式产生Integer对象，判断其是否相等，注意这里使用了“==”，这说明判断的不是同一个对象。我们输入三个数字127、128、555，结果如下：

  1. ====127 的相等判断======  
  2. new产生的对象：false  
  3. 基本类型转换的对象：true  
  4. valueOf产生的对象：true 
  5.  
  6. ====128 的相等判断======  
  7. new产生的对象：false  
  8. 基本类型转换的对象：false  
  9. valueOf产生的对象：false 
  10.  
  11. ====555 的相等判断======  
  12. new产生的对象：false  
  13. 基本类型转换的对象：false  
  14. valueOf产生的对象：false 

 

很不可思议呀，数字127的比较结果竟然与其他两个数字不同，它的装箱动作所产生的对象竟然是同一个对象，valueOf产生的也是同一个对象，但是大于127的数字128和555在比较过程中所产生的却不是同一个对象，这是为什么？我们一个一个来解释。

（1）new产生的Integer对象

new声明的就是要生成一个新的对象，没二话，这是两个对象，地址肯定不等，比较结果为false。

（2）装箱生成的对象

对于这一点，首先要说明的是装箱动作是通过valueOf方法实现的，也就是说后两个算法是相同的，那结果肯定也是一样的，现在的问题是：valueOf是如何生成对象的呢？我们来阅读一下Integer.valueOf的实现代码：

  1. public static Integer valueOf(int i) {  
  2.      final int offset = 128;  
  3.      if (i >= -128 && i <= 127) { // must cache  
  4.         return IntegerCache.cache[i + offset];  
  5.      }  
  6.   return new Integer(i);  
  7. } 

 

这段代码的意思已经很明了了，如果是-128到127之间的int类型转换为Integer对象，则直接从cache数组中获得，那cache数组里是什么东西，代码如下：

  1. static final Integer cache[] = new Integer[-(-128) + 127 + 1];  
  2.  
  3. static {  
  4.      for(int i = 0; i < cache.length; i++)  
  5.       cache[i] = new Integer(i - 128);  
  6. } 

cache是IntegerCache内部类的一个静态数组，容纳的是﹣128到127之间的Integer对象。通过valueOf产生包装对象时，如果int参数在﹣128和127之间，则直接从整型池中获得对象，不在该范围的int类型则通过new生成包装对象。

明白了这一点，要理解上面的输出结果就迎刃而解了，127的包装对象是直接从整型池中获得的，不管你输入多少次127这个数字，获得的对象都是同一个，那地址当然都是相等的。而128、555超出了整型池范围，是通过new产生一个新的对象，地址不同，当然也就不相等了。

以上的解释也是整型池的原理，整型池的存在不仅仅提高了系统性能，同时也节约了内存空间，这也是我们使用整型池的原因，也就是在声明包装对象的时候使用valueOf生成，而不是通过构造函数来生成的原因。顺便提醒大家，在判断对象是否相等的时候，最好是用equals方法，避免用“==”产生非预期结果。

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

posted @ 2016-03-17 20:16  红尘Dream  阅读(190)  评论(1)  编辑  收藏  举报