课程咨询 :186 8716 1620      qq:2066486918

昆明Java培训 > 达内新闻 > 优先使用整型池
  • 优先使用整型池

    发布:昆明Java培训      来源:达内新闻      时间:2016-09-30

  • 上一个昆明Java培训的老师建议我们解释了包装对象的比较问题,本建议将继续深入讨论相关问题,首先看看如下代码:

    1 import java.util.Scanner;

    2

    3 public class Client28 {

    4    public static void main(String[] args) {

    5        Scanner input = new Scanner(System.in);

    6        while (input.hasNextInt()) {

    7            int tempInt = input.nextInt();

    8            System.out.println("\n=====" + tempInt + "的相等判断=====");

    9            //两个通过new产生的对象

    10            Integer i = new Integer(tempInt);

    11            Integer j = new Integer(tempInt);

    12            System.out.println(" new产生的对象:" + (i == j));

    13            //基本类型转换为包装类型后比较

    14            i = tempInt;

    15            j = tempInt;

    16            System.out.println("基本类型转换的对象:" + (i == j));

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

    18            i = Integer.valueOf(tempInt);

    19            j = Integer.valueOf(tempInt);

    20            System.out.println(" valueOf产生的对象:" + (i == j));

    21        }

    22    }

    23 }

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

    127

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

    new产生的对象:false

    基本类型转换的对象:true

    valueOf产生的对象:true

    128

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

    new产生的对象:false

    基本类型转换的对象:false

    valueOf产生的对象:false

    555

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

    new产生的对象:false

    基本类型转换的对象:false

    valueOf产生的对象:false

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

    (1)、new产生的Integer对象

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

    (2)、装箱生成的对象

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

    1 /**

    2     * Returns an {@code Integer} instance representing the specified

    3     * {@code int} value. If a new {@code Integer} instance is not

    4     * required, this method should generally be used in preference to

    5     * the constructor {@link #Integer(int)}, as this method is likely

    6     * to yield significantly better space and time performance by

    7     * caching frequently requested values.

    8     *

    9     * This method will always cache values in the range -128 to 127,

    10     * inclusive, and may cache other values outside of this range.

    11     *

    12     * @param i an {@code int} value.

    13     * @return an {@code Integer} instance representing {@code i}.

    14     * @since 1.5

    15     */

    16    public static Integer valueOf(int i) {

    17        assert IntegerCache.high >= 127;

    18        if (i >= IntegerCache.low && i <= IntegerCache.high)

    19            return IntegerCache.cache[i + (-IntegerCache.low)];

    20        return new Integer(i);

    21    }

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

    1 /**

    2     * Cache to support the object identity semantics of autoboxing for values between

    3     * -128 and 127 (inclusive) as required by JLS.

    4     *

    5     * The cache is initialized on first usage. The size of the cache

    6     * may be controlled by the -XX:AutoBoxCacheMax=<size> option.

    7     * During VM initialization, java.lang.Integer.IntegerCache.high property

    8     * may be set and saved in the private system properties in the

    9     * sun.misc.VM class.

    10     */

    11

    12    private static class IntegerCache {

    13        static final int low = -128;

    14        static final int high;

    15        static final Integer cache[];

    16

    17        static {

    18            // high value may be configured by property

    19            int h = 127;

    20            String integerCacheHighPropValue =

    21                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");

    22            if (integerCacheHighPropValue != ull) {

    23                int i = parseInt(integerCacheHighPropValue);

    24                i = Math.max(i, 127);

    25                // Maximum array size is Integer.MAX_VALUE

    26                h = Math.min(i, Integer.MAX_VALUE - (-low));

    27            }

    28            high = h;

    29

    30            cache = new Integer[(high - low) + 1];

    31            int j = low;

    32            for(int k = 0; k < cache.length; k++)

    33                cache[k] = new Integer(j++);

    34        }

    35

    36        private IntegerCache() {}

    37    }

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

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

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

    昆明Java培训的老师提醒大家注意:通过包装类型的valueOf生成的包装实例可以显著提高空间和时间性能。

    推荐文章

上一篇:谨慎包装类型的大小比较

下一篇:java程序:优先选择基本类型

最新开班日期  |  更多

Java--零基础全日制班

Java--零基础全日制班

开班日期:12/29

Java--零基础业余班

Java--零基础业余班

开班日期:12/29

Java--周末提升班

Java--周末提升班

开班日期:12/29

Java--零基础周末班

Java--零基础周末班

开班日期:12/29

  • 网址:http://km .java.tedu.cn      地址:昆明市官渡区春城路62号证券大厦附楼6楼
  • 课程培训电话:186 8716 1620      qq:2066486918    全国服务监督电话:400-827-0010
  • 服务邮箱 ts@tedu.cn
  • 2001-2016 达内国际公司(TARENA INTERNATIONAL,INC.) 版权所有 京ICP证08000853号-56