JAVA的各种常量池

Integer常量池

在Integer或者Long变量中，如果要使用 == 进行值的比较，则需要注意数值是否在-128~127这个范围内，如果不在则不能比较，以下源码可以解释疑问:
首先我们看先int装箱的代码:

从代码中可以明确的看出并不是所有传入的int变量都进行统一处理，而是在一个范围内的进行统一处理（可从IntegerCache源码中得知这个范围是-128~127），范围外的进行统一处理，范围外的使用的是new 关键字创建的对象，如果是new 出来的则就代表它存在与堆中并且不为基本数据类型了，故不能再使用 == 进行值的比较了

 public static Integer valueOf(int i) {
     if (i >= IntegerCache.low && i <= IntegerCache.high)
         return IntegerCache.cache[i + (-IntegerCache.low)];
     return new Integer(i);
 }

源码为

/**
     * 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.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */
 
    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 < 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 方法上注释大概意思

缓存以支持 JLS 要求的 -128 和 127（含）之间值的自动装箱的对象标识语义。
缓存在第一次使用时初始化。 缓存的大小可以由 -XX:AutoBoxCacheMax=<size> 选项控制。
在VM初始化过程中，java.lang.Integer.IntegerCache.high属性可能会被设置并保存在sun.misc.VM类的私有系统属性中。

Integer类中存在一个缓冲范围，有一个规范叫JSL（Java Language Specification，java语言规范）对Integer的缓冲做了约束，规定其范围为：（-128-127）之间
这的IntegerCache有一个静态的Integer数组，在类加载时就将 -128 到 127 的Integer对象创建了，并保存在cache数组中，一旦程序调用valueOf 方法，如果 变量i 的值是在-128 到 127 之间就直接在cache缓存数组中去取Integer对象。

如果超出了范围，会从堆区new一个Integer对象来存放值

1、Java中，在-128~127的Integer值并且以

Integer x = value;

的方式赋值的Integer值在进行==和equals比较时，都会返回true，因为Java里面对处在在-128~127之间的Integer值，用的是原生数据类型int，会在整数型常量内存池里，也就是说这之间的Integer值进行==比较时只是进行int原生数据类型的数值比较，而超出-128~127的范围，进行== 比较时是进行地址及数值比较

2、如果通过

Integer x = new Integer("127");

方式创建，还是和以前创建对象引用一样，在堆区中创建一个对象，然后将栈中引用指向这个对象，因此 i7 和 i8两个引用内存地址不同

(静态)常量池

每一个class文件都有一个常量池,常量池保存着class的常量信息:字面量和符号引用.常量池技术class文件中的资源仓库,保存了文件运行时需要的常量信息,这些常量都是开发者定义出来的.

我们知道每一个class文件都是javac编译出来的,在编译过程中,java并没有保存方法,字段的内部布局,在运行时必须加载解析这些常量信息才能编译到具体的内存地址加以使用

字面量

通俗的讲，字面量就是由字母、数字构成的字符串或数值。且字面量只可以右值出现，例如 a = 123, 123就是字面量。在这里要注意，编译后运行前，字符串也是字面量，也会存在常量池中，只不过这里的常量池就像个静态池。

符号引用

符号引用是编译原理中的概念，是相对于直接引用来的，主要包括以下三类常量：类的全限定名，字段的名称和描述符以及方法的名称和描述符。简单来说，就是存储了类和方法的入口信息。方便运行时加载入实际内存中。
类的全限定名：就是类名全称，带包路径的，用点隔开，例如java.lang.String
字段的名称和描述符：这里的难点在于字段是什么？字段和属性不同，其实就是类变量（static修饰的变量）
方法的名称和描述符：这个很好理解，就是方法名，修饰符，参数

常量池可以看作是一张表，虚拟机指令根据这张常量表找到要执行的类名,方法名,参数类型，字面量等类型。

运行时常量池

JDK1.8中字符串常量池和运行时常量池逻辑上属于方法区，但是实际存放在堆内存中

运行时常量池（Runtime Constant Pool），它是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到常量池中。

运行时常量是相对于常量来说的，它具备一个重要特征是：动态性。当然，值相同的动态常量与我们通常说的常量只是来源不同，但是都是储存在池内同一块内存区域。Java语言并不要求常量一定只能在编译期产生，运行期间也可能产生新的常量，这些常量被放在运行时常量池中。这里所说的常量包括：基本类型包装类（包装类不管理浮点型，整形只会管理-128到127）和String（也可以通过String.intern()方法可以强制将String放入常量池）

基本包装类型所谓的常量池其实就是一个

static final Integer cache[];

包装类型

java中基本类型的包装类的大部分都实现了常量池技术，即Byte,Short,Integer,Long,Character,Boolean。这5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。 两种浮点数类型的包装类Float,Double并没有实现常量池技术。

String常量池是JVM层面的,但包装类是java层面的

非final的成员变量在堆里，final类型的成员变量存放在方法区的常量池中

永久代和元空间

永久代

1、PermGen（永久代）
PermGen ， 就是 PermGen space ，全称是 Permanent Generation space ，是指内存的永久保存区域。这块内存主要是被JVM存放Class和Meta信息的， Class 在被 Loader 时就会被放到 PermGen space 中。

绝大部分 Java 程序员应该都见过 java.lang.OutOfMemoryError: PermGen space 这个异常。
这里的 PermGen space 其实指的就是 方法区 。不过 方法区 和 PermGen space又有一定的区别。

方法区 是 JVM 的规范，所有虚拟机 必须遵守的。常见的JVM 虚拟机 Hotspot 、 JRockit（Oracle）、J9（IBM）

PermGen space 则是 HotSpot 虚拟机 基于 JVM 规范对 方法区 的一个落地实现， 并且只有 HotSpot 才有 PermGen space。

而如 JRockit（Oracle）、J9（IBM） 虚拟机有 方法区 ，但是就没有 PermGen space。

PermGen space 是 JDK7及之前， HotSpot 虚拟机 对 方法区 的一个落地实现。在JDK8被移除。

Metaspace（元空间）是 JDK8及之后，废弃了 PermGen space ，取而代之的是 Metaspace ， 这是 HotSpot 虚拟机 对 方法区 的新的落地实现。

JDK6、JDK7 时，方法区 就是 PermGen（永久代）。
JDK8 时，方法区就是 Metaspace（元空间）

由于方法区 主要存储类的相关信息，所以对于动态生成类的情况比较容易出现永久代的内存溢出。

JDK6 、JDK7 存在 PermGen space；

JDK8 中， Hotspot 已经没有 PermGen space ，取而代之是一个叫做 Metaspace（元空间） 。

下面我们就来看看 Metaspace 与 PermGen space 的区别。

Metaspace元空间

Metaspace（元空间）和 PermGen（永久代）类似，都是对 JVM规范中方法区的一种落地实现。

不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。

Oracle 移除PermGen（永久代）从从JDK7 就开始。例如，字符串内部池，已经在JDK7 中从永久代中移除。直到JDK8 的发布将宣告 PermGen（永久代）的终结。

其实，移除 PermGen 的工作从 JDK7 就开始，永久代的部分数据就已经转移到了 Java Heap 或者是 Native Heap。

但永久代仍存在于JDK7 中，并没完全移除，比如：

字面量 （interned strings）转移到 Java heap；

类的静态变量（class statics）转移到Java heap ；

符号引用（Symbols） 转移到 Native heap ；

元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用 本地内存。默认情况下，元空间的大小仅受 本地内存 限制