Question

我使用Sonar使我的代码更清晰，并指出我使用的是new Integer(1)而不是Integer.valueOf(1)。因为valueOf似乎没有实例化新对象，所以更加内存友好。 valueOf如何不实例化新对象？它是如何工作的？对于所有整数都是如此吗？

Answer 1

Integer.valueOf为值-128到+127实现缓存。请参阅Java语言规范的最后一段，第5.1.7节，其中解释了装箱的要求（通常根据.valueOf方法实现）。

http://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.1.7

Answer 2

来自JavaDoc：

public static Integer valueOf（int i）返回表示指定int值的Integer实例。如果不需要新的Integer实例，通常应优先使用此方法，而不是构造函数Integer（int），因为此方法可能通过缓存频繁请求的值来显着提高空间和时间性能。

ValueOf通常用于自动装箱，因此（当用于自动装箱时）缓存至少从-128到127的值，以遵循自动装箱规范。

以下是Sun JVM 1.5的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);
}

Answer 3

他们正在推动您使用valueOf()而不是new Integer()，因此方法valueOf()会为您执行此操作，并缓存该值以防您希望以后再次使用相同的数字。在这种情况下，方法不会实例化新的Integer，但是会给你缓存的那个，什么会使新的Integer'创建'更快更快和内存友好的过程..

这样，如果你是没有经验的java程序员，你可能会遇到很多问题，因为你会得出结论Integer.valueOf(342)==Integer.valueOf(342)，因为你可能（或可能没有）对两个整数有相同的指针，可能你会练习在某种程度上，比方说，你在C＃中学到了，所以它会不时地向你显示错误，你不会知道怎样＆amp;那些人来自...

Answer 4

来自java.lang.Integer源代码。整数缓存是可配置的。要配置除Sun之外的整数缓存大小，我们需要根据源代码使用系统属性java.lang.Integer.IntegerCache.high。

/**
 * 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. During VM initialization the
 * getAndRemoveCacheProperties method may be used to get and remove any system
 * properites that configure the cache size. At this time, the size of the
 * cache may be controlled by the vm option -XX:AutoBoxCacheMax=<size>.
 */

// value of java.lang.Integer.IntegerCache.high property (obtained during VM init)
private static String integerCacheHighPropValue;

static void getAndRemoveCacheProperties() {
    if (!sun.misc.VM.isBooted()) {
        Properties props = System.getProperties();
        integerCacheHighPropValue =
            (String)props.remove("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null)
            System.setProperties(props);  // remove from system props
    }
}

private static class IntegerCache {
    static final int high;
    static final Integer cache[];

    static {
        final int low = -128;

        // high value may be configured by property
        int h = 127;
        if (integerCacheHighPropValue != null) {
            // Use Long.decode here to avoid invoking methods that
            // require Integer's autoboxing cache to be initialized
            int i = Long.decode(integerCacheHighPropValue).intValue();
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - -low);
        }
        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() {}
}

从java.lang.Short，java.lang.Byte和java.lang.Long创建127到-128的缓存

private static class LongCache {
    private LongCache() {
    }

    static final Long cache[] = new Long[-(-128) + 127 + 1];

    static {
        for (int i = 0; i < cache.length; i++)
            cache[i] = new Long(i - 128);
    }
}

private static class ShortCache {
    private ShortCache() {
    }

    static final Short cache[] = new Short[-(-128) + 127 + 1];

    static {
        for (int i = 0; i < cache.length; i++)
            cache[i] = new Short((short) (i - 128));
    }
}

private static class ByteCache {
    private ByteCache() {
    }

    static final Byte cache[] = new Byte[-(-128) + 127 + 1];

    static {
        for (int i = 0; i < cache.length; i++)
            cache[i] = new Byte((byte) (i - 128));
    }
}

New Integer vs valueOf

4 个答案: