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

    }
}

Probably because Strings are more likely to be reused (you may print the same string many times over the course of a program) and generally have a much larger memory footprint. — Chris Hayes, Dec 05 '13 at 07:41
AFAIK , java finally converts everything in to string thus string has the biggest requirement of being kep in constant pool , others are a little in existence — Hussain Akhtar Wahid 'Ghouri', Dec 05 '13 at 07:42
@HussainAkhtarWahid : Could you provide links to some online resources / JVM specs which support this theory ? — Amit Sharma, Dec 05 '13 at 07:43
@HussainAkhtarWahid That explanation makes no sense whatsoever. — chrylis -cautiouslyoptimistic-, Dec 05 '13 at 08:06
Btw: this code looks like it has an error in it. Under the long test, you're using "`i == j`" which references the shorts. — Justin Blank, Jul 09 '14 at 15:03
If string is pooled in a special memory area called "String Constant Pool", then what we can say the memory area which pools numerals? — my name is GYAN, Apr 28 '16 at 10:51

score 9 · Accepted Answer · answered Dec 05 '13 at 08:06

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 String carries 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.

"Most particular numbers aren't ever used in a given program's code. " - I did not understand this part. Could you please elaborate ? — Amit Sharma, Dec 05 '13 at 14:25
@AmitSharma There are billions of possible `int` values and an incomprehensible number of `long`s. Most programs only use a handful, like zero, one, a few powers of two and ten, and domain-specific values. — chrylis -cautiouslyoptimistic-, Dec 05 '13 at 20:28
If integers are not pooled, then why is there a Constant_Integer pool type, is that just legacy? — Victor Grazi, Nov 22 '15 at 00:23

Amit Kumar user3037405 · Answer 2 · 2013-12-05T08:15:02.093

Well, because String objects are immutable, it's safe for multiple references to "share" the same String object.

public class ImmutableStrings
{
public static void main(String[] args)
{
    String one = "str1";
    String two = "str1";

    System.out.println(one.equals(two));
    System.out.println(one == two);
}
}

// Output

true
true

In such a case, there is really no need to make two instances of an identical String object. If a String object could be changed, as a StringBuffer can be changed, we would be forced to create two separate objects. But, as we know that String objects cannot change, we can safely share a String object among the two String references, one and two. This is done through the String literal pool.

You can go through this link to know in details.

While this is all true, it doesn't address the question, which is why this isn't done for other immutable primitive types. — Chris Hayes, Dec 05 '13 at 08:44

Java: Why is constant pool maintained only for String values ?

2 Answers2

Linked