Java基础二：常量池

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

目录：

自动装箱与拆箱
常量池
==与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;
}