integet c=128； integer d=128；a==b(false) 这不是绝对的！

测试类代码如下：

        Integer a=100;
        Integer b=100;
        System.out.println(a==b);  //true
        
//      Integer i =100实际在内部做了
//      Integer i = Integer.valueOf(100)的操作。
//      Integer的数，如果在-128和127之间，那么它们之间的内存地址是相同的。

        Integer c=128;
        Integer d=128;
        
        System.out.println(c==d);//false
//     底层代码“high本身没有值，是h=127赋给它的，而h的值在这之前可能会改变。也就是说缓存上限的127其实是可以改变
//      ava.lang.Integer.IntegerCache.high中读取为上限，但是需要满足这个上限的值确实在-128和127之间。

底层代码：

    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 =
                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 < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

底层的意思是： 如果定义的变量值 在IntegerCache.low与IntegerCache.high之间，那就看看前面缓存中cache中有没有这个值，如果有这个值的话就直接返回，否则就返回一个新的Integer实例。IntegerCache.low的默认值是-128，IntegerCache.high的默认值是127。

从底层中可以看到 h实际上是没有值的，默认给它赋了一个最大值。再看赋值上面的注释
// high value may be configured by property （高值可以由属性配置）也就是说这个值是可以修改的。那么修改后 c==d 还是false 吗？