新的整数与值 - 开卷题库

小开

最佳答案

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

小开

Public static Integer value Of (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);
}

小开

他们强迫你使用 valueOf()而不是 new Integer()，所以方法 valueOf()会为你做这件事，并且缓存这个值，以防将来你想再次得到相同的数字。在这种情况下，方法不会实例化新的 Integer，但会给你缓存的一个，这将使“创建”新的 Integer 更快和内存友好的过程。.

这样的话，如果你是一个没有经验的 Java 程序员，你可能会给自己带来很多问题，因为你可能会得出 Integer.valueOf(342)==Integer.valueOf(342)的结论，因为你可能(也可能不会)有两个相同的整数指针，而且你可能会以某种方式来练习它，比如说，你在 C # 中学过，所以它会时不时地向你展示 bug，而你不会知道这些 bug 是怎么来的，从哪里来的..。

小开

来自 java.lang。整数源代码。整数缓存是可配置的。要配置 Sun 以外的 Integer 缓存大小，我们需要根据源代码使用 System 属性 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));
}
}