问题一:
一直很好奇一件事,类似于Integer i = 15; String s = “aa”;之类的代码是怎么实现的?
Integer和String是一个类,i,s是对应的对象,对象的创建需要new出来(不讨论反射),但是上面的对象怎么创建的?
于是去找Integer的构造函数,在第849行找到了。。。(构造函数不都放在前面么),如下:
private final int value;
public Integer(int value) {
this.value = value;
}
public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);
}
只此两个构造函数,一个传入int形参,一个传入String形参。还是没解决问题!按理说应该且必须类似于new Integer(10);这样创建对象啊!!
于是在Integer类中搜索"new Integer("字样。一共搜索到了两处,一处在内部类IntegerCache中出现,一处在public static Integer valueOf(int i){}方法体中出现,并且该方法体中出现了IntegerCache内部类,更神奇的是内部类IntegerCache只在该方法体中出现,于是得出结论:该内部类就是为该方法而创建。于是分析一下这个ValueOf(int i)方法:
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
看到最后一个return语句,那肯定可以通过valueOf这个静态方法创建对象,实验一下果然成功了。
所以Integer只有两种方式创建对象:直接创建和间接创建。①new Integer(10) ②Integer.valueOf(10)。开头那种神奇的方法是用哪一种??
于是通过反编译工具将代码生成java文件后,神奇发现Integer i = 10变成了Integer i = Integer.valueOf(10);
所以问题解决了,编译器将代码处理成了valueOf方法去创建对象!!
问题二:
好像没什么问题了,想了想为什么编译器不直接处理成new integer(10);上文可说了有两种创建对象的方法,那个内部类是干什么用的?还专门为valueOf(int i)方法创建一个内部类?
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
再看这个方法,只有i值在[IntegerCache.low, IntegerCache.high]范围内才会调用内部类创建对象,并且返回的是类成员变量cache数组的一个值,那这个数组里面肯定就是存的对象咯。再看看这个内部类。
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() {}
}
读完意思就是:类静态变量cache存储-128到127之间的Integer对象,静态代码块已经初始化好了。
也就意味着valueOf(int i)中i在-128到127之间时,直接去cache中根据下标取对象就行,对象已经创建好了。
问题三:
那?这是何必呢?是不是还意味着Integer a = 10; Integer b = 10;后a和b是同一个对象呢?不知道。用==号实验一下,果然,结果是ture!
那么用意何在?
个人猜测是为了避免反复创建-128到127之间的相同对象吧。那。那也创建了256个对象?能节约内存?
常用方法:
① int转Integer
public int intValue() {
return value;
}
② String转Integer
//若字符串中有非数字则抛异常
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
③ Integer转其他七个基本数据类型
public byte byteValue() {
return (byte)value;
}
public short shortValue() {
return (short)value;
}
public int intValue() {
return value;
}
public long longValue() {
return (long)value;
}
public float floatValue() {
return (float)value;
}
public double doubleValue() {
return (double)value;
}
public String toString() {
return toString(value);
}