目录:
- 自动装箱与拆箱
- 常量池
- ==与equals()区别
1. 自动装箱与拆箱
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()区别
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,下一篇博客再详细阐述。