title: Why does the JVM allow to set the "high" value for the IntegerCache, but not the "low"?
body: <p>We all know that Java has a cache for <code>Integer</code> (and some other types) for number in the range <code>[-128, 127]</code> which are considered to be "commonly used". </p>
  
  <p>The cache is designed as follow :</p>
  
  <pre><code>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) {
              try {
                  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);
              } catch( NumberFormatException nfe) {
                  // If the property cannot be parsed into an int, ignore it.
              }
          }
          high = h;
  
          cache = new Integer[(high - low) + 1];
          int j = low;
          for(int k = 0; k &lt; cache.length; k++)
              cache[k] = new Integer(j++);
  
          // range [-128, 127] must be interned (JLS7 5.1.7)
          assert IntegerCache.high &gt;= 127;
      }
  
      private IntegerCache() {}
  }
  </code></pre>
  
  <p>I know that I can extend the <code>high</code> value by giving a parameter to the JVM :</p>
  
  <pre><code>java -Djava.lang.Integer.IntegerCache.high=xxxx Aclass.class
  </code></pre>
  
  <p>What I don't understand is why aren't we allowed to override the <code>low</code> value ?</p>
  
  <p>Note that I was not trying to find a workaround, but instead understand why it is not allowed for some obscure reasons.</p>