java基本类型相关常量池管理

JVM只对基本类型部分的数值保存在常量池里面：

 

 说明：

http://stackoverflow.com/questions/20394116/java-why-is-constant-pool-maintained-only-for-string-values

 

Question:

My question is about java interning and constant pools.

Java maintains a a constants pool for java.lang.String, to use JVM memory cleverly, and to do so java.lang.String is made immutable. So why doesn't java maintain constant pools of other immutable types, such as Long, Integer, Char, Short ? Wouldn't that save memory too ?

I am aware of the fact that Integers are pooled for value range [-127, 127], though I do not understand the reason for choosing this range.

Here's a test code I wrote to test pooling of other immutable data types.

public class PoolTest {

	public static void main(String... args) {

		// Pooling of Integer [-127, 127]
		Integer x = 127, y = 127;
		System.out.println("Integer:" + (x == y)); // prints true
		x = 129;
		y = 129;
		System.out.println("Integer:" + (x == y)); // prints false

		// Apparent pooling of short [-127, 127]
		Short i = 127, j = 127;
		System.out.println("Short: " + (i == j)); // prints true
		i = 128;
		j = 128;
		System.out.println("Short: " + (i == j)); // prints false

		// No pooling of long values
		Long k = 10L, l = 10L;
		System.out.println("Long: " + (i == j)); // prints false
		k = 128L;
		l = 128L;
		System.out.println("Long: " + (i == j)); // prints false

	}
}

 

Answer:

The purpose of a constant pool is to reduce the memory overhead required by keeping multiple copies of constants. In the case of Strings, the JVM is inherently required to keep some object around for each individually distinguishable constant, and the Java spec basically says that the JVM should deduplicate String objects when class loading. The ability to manually place Strings in the pool via intern is inexpensive and allows programmers to identify particular values (such as properties) that are going to be around for the life of the program and tell the JVM to put them out of the way of normal garbage collection.

Pooling numeric constants, on the other hand, doesn't make a lot of sense, for a few reasons:

• Most particular numbers aren't ever used in a given program's code.
• When numbers are used in code, embedding them in the code as immediate opcode values is less expensive in terms of memory than trying to pool them. Note that even the empty Stringcarries around a char[], an int for its length, and another for its hashCode. For a number, by contrast, a maximum of eight immediate bytes is required.
• As of recent Java versions, Byte, Short, and Integer objects from -128 to 127 (0 to 127 for Character) are precached for performance reasons, not to save memory. This range was presumably chosen because this is the ranged of a signed byte, and it will cover a large number of common uses, while it would be impractical to try to precache a very large number of values.

As a note, keep in mind that the rules about interning were made long before the introduction of autoboxing and generic types in Java 5, which significantly expanded how much the wrapper classes were casually used. This increase in use led Sun to add those common values to a constant pool.