Java基础二：常量池

目录：

1. 自动装箱与拆箱
2. 常量池
3. ==与equals()区别

---

 　　1. 自动装箱与拆箱

　　Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），如int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。 
Java 为每个基本类型提供了包装类型： 

• 原始类型: boolean，char，byte，short，int，long，float，double
• 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

　　首先看一个简单例子：

public class AutoUnboxingTest {
 public static void main(String[] args) {
        Integer a = new Integer(3);
        Integer b = 3;                  // 将3自动装箱成Integer类型
        int c = 3;
        System.out.println(a == b);     // false 两个引用没有引用同一对象
        System.out.println(a == c);     // true a自动拆箱成int类型再和c比较
       
        Integer f1 = 3, f2 = 3, f3 = 150, f4 = 150;
        System.out.println(f1 == f2);//true
        System.out.println(f3 == f4);//false
       
        Integer p1 = new Integer(3);
        Integer p2 = new Integer(3);
        Integer p3 = new Integer(0);
        System.out.println(p1 == p2);//false，两个不同的对象
        System.out.println(p1 == p2+p3); //true p2和p3自动拆箱为int类型，p1也会自动拆箱，本质为基本数据类型比较
    }
}

 　　用new关键字创建一个新对象，它们的内容可以相同，但其内存中存放的地址不同。而==对对象来说，是比较的内存地址，不同的对象自然不同，故（a、b）（p1、p2）比较为false。那么f1、f2、f3、f4四个变量都是Integer对象引用，为什么会出现一个false一个true呢？这就涉及装箱的本质，当我们给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf，想知道发生了什么，直接上源码：

/**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
19             return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

　　其调用了Integer的内部类IntegerCache，源码如下：

/**
     * 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 -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) {
                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);
            }
            high = h;
27             cache = new Integer[(high - low) + 1];
28             int j = low;
29             for(int k = 0; k < cache.length; k++)
30                 cache[k] = new Integer(j++);
        }
        private IntegerCache() {}
    }

 

　　源码中标红的部分是重点，在第一次自动装箱时，程序即会创建[-128 ~ 127]区间的Integer，存在cache数组中，并且数组和256个Integer对象都在堆内存中。所有在该区间的比较对应结果为true,故（f1、f2）为true；超出该区间将重新创建对象，故（f3、f4）为false。其实这就涉及常量池的概念了。

　　 2. 常量池

　　常量池是JVM的一种内存空间，用来存放编译后确定的数据和文本形式的符号引用，其采用11种常量表进行存储（后续博客介绍），并且对6种基本数据类型（对一定范围内的数值）和String等都有常量池的应用，用来快速创建对应的对象。

　　其中6种基本数据类型（原理与上边一致,另外两种浮点数类型的包装类则没有实现）常量范围如下：

类型	范围
Boolean	true false
Character	'\u0000' to '\u007F'（0-127）
Byte	all byte values are cached
Short	-128 ~ 127
Integer	-128 ~ 127
Long	-128 ~ 127

　　百度百科对常量池的介绍：Java是一种动态链接的语言，常量池的作用非常重要，常量池中除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值外，还包含一些以文本形式出现的符号引用，比如：类和接口的全限定名；字段的名称和描述符；方法的名称和描述符。在源码编译成字节码时，存在一块叫做“Constant pool”的区域，用来存放常量和符号引用等。

　　下一篇博客将介绍String与常量池的内容。

　　3. ==与equals()区别

　　Java中数据类型分为两类：

　　基本数据类型，采用==比较的是它们的值；

　　复合数据类型（类），采用==比较的是它们的内存地址。

　　Java中多数的类都继承于Object基类，其中有定义equals()方法，该方法的初始行为是比较对象的内存地址。一些类库重写了该方法，如String、Integer、Date等，equals()直接对其值进行比较，而不是类在堆内存中的存放地址；对没有重写该方法的类，比较的仍然是内存地址，相当于==。上源码：

　　Object中的equals()方法：

public boolean equals(Object obj) {
        return (this == obj);
    }

 　　String重写后（对每个char进行比较）：

/**
     * Compares this string to the specified object.  The result is {@code
     * true} if and only if the argument is not {@code null} and is a {@code
     * String} object that represents the same sequence of characters as this
     * object.
     *
     * @param  anObject
     *         The object to compare this {@code String} against
     *
     * @return  {@code true} if the given object represents a {@code String}
     *          equivalent to this string, {@code false} otherwise
     *
     * @see  #compareTo(String)
     * @see  #equalsIgnoreCase(String)
     */
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

  

全文总结：

•  自动装箱与拆箱，涉及基本数据类型的常量池（一定范围内）；
•  常量池的概念，后续会在介绍Java内存模型时详细介绍；
• ==与equals()方法的区别，会在面试中问到，尤其涉及String，下一篇博客再详细阐述。