理解Java中的Integer的实例化

Integer类在Java中表示整数类,它是基本类型int的自动装箱的类,本文从自动装箱和内存占用两个方面分析它的实例化方法的异同。

如何实例化

Integer i = 1;

上面这行代码是如何实现的呢?通过 javap -c
我们可以看到对应的字节码,通过分析可知,其实内部调用了 Integer.valueOf()
方法。

我们平时应该都用过或者见过 parseInt
valueOf
这两个方法。一般我们是想把 String
类型的字符串数字转成 int
类型。从这个功能层面来说,这两个方法都一样,都可以胜任这个功能。

但是在性能和实现细节上二者有非常大的区别,想写出更高效的代码还需要对此有深刻的认识。

parseInt方法

JDK
中的实现代码如下:

ublic static int parseInt(String s, int radix) throws NumberFormatException{
    /*
     * WARNING: This method may be invoked early during VM initialization
     * before IntegerCache is initialized. Care must be taken to not use
     * the valueOf method.
     */
    if (s == null) {
        throw new NumberFormatException("null");
    }

    if (radix < Character.MIN_RADIX) {
        throw new NumberFormatException("radix " + radix +" less than Character.MIN_RADIX");
    }

    if (radix > Character.MAX_RADIX) {
            throw new NumberFormatException("radix " + radix +" greater than Character.MAX_RADIX");
    }

    int result = 0;
    boolean negative = false;
    int i = 0, len = s.length();
    int limit = -Integer.MAX_VALUE;
    int multmin;
    int digit;

    if (len > 0) {
        char firstChar = s.charAt(0);
        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') {
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+')
                 throw NumberFormatException.forInputString(s);

            if (len == 1) // Cannot have lone "+" or "-"
                 throw NumberFormatException.forInputString(s);
            i++;
        }
        multmin = limit / radix;
        while (i < len) {
            // Accumulating negatively avoids surprises near MAX_VALUE
            digit = Character.digit(s.charAt(i++),radix); //传入一个字符参数和基数,返回一个int值
            if (digit < 0) {
                throw NumberFormatException.forInputString(s);
            }
            if (result < multmin) {
                throw NumberFormatException.forInputString(s);
            }
            result *= radix;
            if (result < limit + digit) {
                throw NumberFormatException.forInputString(s);
            }
            result -= digit;
        }
    } else {
         throw NumberFormatException.forInputString(s);
    }
    return negative ? result : -result;
}

值得注意的是为了防止越界,默认使用了负数进行计算。

valueOf方法

  • 字符串参数
    public static Integer valueOf(String s) throws NumberFormatException {
      return Integer.valueOf(parseInt(s, 10));
    }

    可以看到,它的内部调用了 parseInt
    方法完成字符串和 int
    的转化,并通过重载方法 valueOf(int)
    完成最终到 Integer
    的转换。

所以为什么在写代码的时候使用下列方式对基本类型数据进行赋值会被某些代码扫描工具(如 FindBug
)提示 Bad Smell
了:

int i = Integer.valueOf(“1”);

因为使用 parseInt
方法可以更高效的完成同样的功能,因为它不需要额外的 auto-boxing
操作。

注:可以通过分别对两个方法的实例化时间进行压测得出结论。此处不再粘贴实验结果

  • int参数
    这个方法也是进行 auto-boxing

    调用的方法。

    public static Integer valueOf(int i) {
      assert IntegerCache.high >= 127;
      if (i >= IntegerCache.low && i <= IntegerCache.high)
          return IntegerCache.cache[i + (-IntegerCache.low)];
      return new Integer(i);
    }

    可以看到这里会对[-128, 127] 之间的数字进行特殊处理:从缓存中拿数据,也就是说不会对这些数据进行冗余保存,但前提是通过 valueOf
    方法获取 Integer
    对象。
    如果使用构造函数,则仍然会每次实例化一个新的对象。

    IntegerCache

    为什么要缓存

    为什么需要缓存?因为数字在程序里出现的频率实在是太高了,并且也太容易被我们忽视它们对内存的影响了。

试想一下,一个数字敏感的业务,如电商中的商品,其中包括价格属性,如果使用 JVM
内存来做缓存,如果商品数量超过一定程度,那么重复的价格的商品个数比例应该会很高。
此时如果每次都用 new Integer(price)
来存储,那么无疑对内存是一种巨大的浪费。

实现代码

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) {
            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);
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
    }

    private IntegerCache() {}
}

注意到它是一个内部静态类,外部无法访问,并且缓存的初始化是在 Integer
类加载的时候就被实例化的。

Byte/Short/Long的缓存池范围默认都是[-128,127]。可以看出,Byte的所有值都在缓存区中,用它生成的相同值对象都是相等的。

只有 IntegerCache
可以通过启动参数来调整缓存的上限, java.lang.Integer.IntegerCache.high=n

References

本文首次发布于S.L’s Blog, 作者 @stuartlau
,
转载请保留原文链接.

  • Previous

    熔断限流利器Resilience4j初探

原文 

https://elsef.com/2019/11/10/理解Java中Integer的实例化/

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 理解Java中的Integer的实例化

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址