文章目录
一、定义
1)何为基本类型?
基本数据类类型存的是数值本身
2)何为引用类型?
引用类型变量在内存放的是数据的引用
3)关系
基本类型int对应的包装类是Integer
基本类型通过==比较的是他们的值大小,而引用类型比较的是他们的引用地址
二、装箱拆箱
1)定义
基本类型与对应的包装类对象之间,来回转换的过程称为装箱和拆箱:
- 装箱:从基本类型转换为对应的包装类对象。
- 拆箱:从包装类对象转换为对应的基本类型。
2)int与Integer的转换
基本数值—>包装对象
//使用构造函数函数
Integer i = new Integer(4);
//使用包装类中的valueOf方法
Integer iii = Integer.valueOf(4);
包装对象—>基本数值
int num = i.intValue();
3)自动装箱与自动拆箱
由于我们经常要做基本类型与包装类之间的转换,从Java 5(JDK 1.5)开始,基本类型与包装类的装箱、拆箱动作可以自动完成。例如:
//自动装箱。相当于Integer i = Integer.valueOf(4);
Integer i = 4;
//等号右边:将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后,再次装箱,把基本数值转成对象。
i = i + 5;
4)基本类型与字符串之间的转换
基本类型直接与””相连接即可;如:34+""
String转换成对应的基本类型
除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型。
int num = Integer.parseInt("100");
二、==关系
public static void main(String[] args) {
int s1 = 1;
int s2 = 1;
int s3 = 200;
int s4 = 200;
Integer Integer1 = 200;
Integer Integer2 = 200;
Integer Integer3 = new Integer(200);
Integer Integer4 = 127;
Integer Integer5 = 127;
System.out.println(s1==s2);
System.out.println(s3==s4);
System.out.println(s3==Integer1);
System.out.println(Integer1==Integer2);
System.out.println(Integer1==Integer3);
System.out.println(Integer4==Integer5);
}
如上执行的结果分别是什么呢?
结果是:TTTFFT
我们先看一下字节码文件
1)int s1== s2 s3== s4
int s1 = 1;
int s2 = 1;
对应的字节码文件如下:
L0
LINENUMBER 11 L0
ICONST_1 将int类型常量1压入操作数栈
ISTORE 1 将int类型值存入局部变量1(也就是给s1)
L1
LINENUMBER 12 L1
ICONST_1 将int类型常量1压入操作数栈
ISTORE 2 将int类型值存入局部变量2(也就是给s2)
在JVM中,操作数栈在栈内存空间中,局部变量在堆空间中,两个指针指向了同一块空间,所以不管基本数据类型value为多少,都是相等值。
2)int s3==Integer integer1
Integer Integer1 = 200;对应的字节码如下,我们可以发现实际是直接走的Integer.valueOf方法,其实就是上边说的装箱过程
L4
LINENUMBER 15 L4
SIPUSH 200
INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
ASTORE 5
所以当int和Integer进行比较,其实和JVM没关系,而是拆箱装箱的过程,值相等==就是TRUE
3)Integer 127==Integer 127
当我们给一个Integer赋予一个int类型的时候会调用Integer的静态方法valueOf。
Integer f1 = Integer.valueOf(200);
Integer f2 = Integer.valueOf(200);
Integer f3 = Integer.valueOf(127);
Integer f4 = Integer.valueOf(127);
思考:那么Integer.valueOf()返回的Integer是不是是重新new Integer(num);来创建的呢?如果是这样的话,那么== 比较返回都是false,因为他们引用的堆地址不一样。
我们来看一个valueOf源码:
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
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() {}
}
low 和high范围就是-128到127。所以如果Integer的值范围是这个区间,直接从cache中获取,这些cache引用对Integer对象地址是不变的,但是不在这个范围内的数字,则new Integer(i) 这个地址是新的地址,不可能一样的。
换句话理解就是:若不在范围内,Integer i=200和new Integer(200)是一样的。