- 一、基本数据类型
- 二、引用数据类型
- 包装器类型
- 三、样例分析
一、基本数据类型
Java中的八种基本数据类型,没有对应的equals()方法,所以在此不做分析。对于“==”,基本数据类型比较的是值
注意:
其实无论是基本数据类型还是引用数据类型,在进行“==”比较时,都可以理解为比较的是值 。只不过对于基本数据类型来说,变量存储的是值,而引用数据类型存的是指向堆中对象的地址。
二、引用数据类型
1)、“==”:对于引用数据类型来说,“ == ”比较的是地址
2)、equals()方法: Object类是所有引用数据类型的基类,其对应的equals()方法如下:
public boolean equals(Object obj) {
return (this == obj);
}
可以看出,Object类的equals()方法比较的也是地址。但是对于覆盖了equals()方法的类型,equals()的结果则由覆盖后的代码决定,一般比较的是内容。
包装器类型比较特殊,稍后单独分析:1)、当 "=="运算符的两个操作数都是包装器类型的引用,则是比较指向的是否是同一个对象,而如果其中有一个操作数是表达式(即包含算术运算),则比较的是数值(即会触发自动拆箱的过程)。
2)、对于包装器类型,equals()方法并不会进行类型转换。若泛型一致,或者参数对象是调用对象的子类,则会发生拆箱过程,比较的是值。
三、样例分析
1)、Integer:下面这段代码的输出结果是什么
public class Test {
public static void main(String[] args) {
Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;
System.out.println(i1==i2);//true
System.out.println(i3==i4);//false
}
}
输出结果表明i1和i2指向的是同一个对象,而i3和i4指向的是不同的对象。此时只需一看源码便知究竟,下面这段代码是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) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
其中IntegerCache类的实现为:
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() {}
}
这个原码可以看出来,在通过valueOf方法创建Integer对象的时候,如果数值在[-128,127]之间,程序便返回指向IntegerCache.cache中已经存在的对象的引用,否则创建一个新的Integer对象。
equals()方法在Integer中运行情况以及Integer重写的equals()方法源码,分析:
第一条: 满足if条件,比较的是值。
第二条: 因为基本数据类型中的int = 10 是Integer的子类,也满足if条件,比较的是值。
第三条: 基本数据类型long = 10 不是Integer的子类,不满足if条件。
总结: 所以对于包装器类型的equals()方法不能单纯的说比较的是值,而是在满足泛型的条件下才比较值。
public class Test {
public static void main(String[] args) {
Integer i = 10;
Integer j = 10;
System.out.println(i.equals(j));//true
System.out.println(i.equals(10));//true
System.out.println(i.equals(10L));//false
}
}
Integer对应的equals()方法:
public boolean equals(Object obj) {
if (obj instanceof Integer) {
//发生了拆箱过程,比较的是基本数据类型对应的值
return value == ((Integer)obj).intValue();
}
return false;
}
Byte对应的equals()方法:
public boolean equals(Object obj) {
if (obj instanceof Byte) {
return value == ((Byte)obj).byteValue();
}
return false;
}
Short对应的equals()方法:
public boolean equals(Object obj) {
if (obj instanceof Short) {
return value == ((Short)obj).shortValue();
}
return false;
}
Long对应的equals()方法:
public boolean equals(Object obj) {
if (obj instanceof Long) {
return value == ((Long)obj).longValue();
}
return false;
}
2)、Double及Float:下面这段代码的输出结果是什么
public class Test {
public static void main(String[] args) {
Double i1 = 100.0;
Double i2 = 100.0;
Double i3 = 200.0;
Double i4 = 200.0;
System.out.println(i1==i2);//false
System.out.println(i3==i4);//false
Float i5 = 100.0f;
Float i6 = 100.0f;
Float i7 = 200.0f;
Float i8 = 200.0f;
System.out.println(i5==i6);//false
System.out.println(i7==i8);//false
}
}
Double及Float对应的valueOf方法如下:
public static Double valueOf(double d) {
return new Double(d);
}
public static Float valueOf(float f) {
return new Float(f);
}
至于具体为什么,可以去查看Double类的valueOf的实现。在这里只解释一下为什么Double类的valueOf方法会采用与Integer类的valueOf方法不同的实现。因为在某个范围内的整型数值的个数是有限的,而浮点数却不是。
equals()方法在Double、Float中运行情况以及重写的equals()方法源码。
public static void main(String[] args) {
Float i = 10F;
Double j = 10D;
System.out.println(i.equals(j));//false
}
Doule对应的equals()方法:
public boolean equals(Object obj) {
return (obj instanceof Double)
&& (doubleToLongBits(((Double)obj).value) ==
doubleToLongBits(value));
}
Float对应的equals()方法:
public boolean equals(Object obj) {
return (obj instanceof Float)
&& (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
}
3)、Boolean:下面这段代码的输出结果是什么
public static void main(String[] args) {
Boolean i1 = false;
Boolean i2 = false;
Boolean i3 = true;
Boolean i4 = true;
System.out.println(i1==i2);//true
System.out.println(i3==i4);//true
}
Boolean对应的valueOf方法如下:TRUE和FALSE都是被final修饰,无法被修改,返回的都是同一个对象,所以对应的地址相同。
public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);
public static Boolean valueOf(String s) {
return parseBoolean(s) ? TRUE : FALSE;
}
equals()方法在Boolean中运行情况以及重写的equals()方法源码。
public boolean equals(Object obj) {
if (obj instanceof Boolean) {
return value == ((Boolean)obj).booleanValue();
}
return false;
}
4)、Character:下面这段代码的输出结果是什么
public static void main(String[] args) {
Character i1 = 100;
Character i2 = 100;
Character i3 = 128;
Character i4 = 128;
System.out.println(i1 == i2);//true
System.out.println(i3 == i4);//false
//Character.valueOf()
}
Character对应的valueOf方法如下:
public static Character valueOf(char c) {
if (c <= 127) { // must cache
return CharacterCache.cache[(int)c];
}
return new Character(c);
}
所以对于Character,当创建的对象在[0,127]时返回的是同一个对象。
equals()方法在Character中运行情况以及重写的equals()方法源码。
public boolean equals(Object obj) {
if (obj instanceof Character) {
return value == ((Character)obj).charValue();
}
return false;
}
5)、包装类的难点及重点:下面这段代码的输出结果是什么
public class Test {
public static void main(String[] args) {
Integer a = 1;
Integer b = 2;
Integer c = 3;
Integer d = 3;
Integer e = 321;
Integer f = 321;
Long g = 3L;
Long h = 2L;
System.out.println(c==d);//true
System.out.println(e==f);//false
System.out.println(c==(a+b));//true
System.out.println(c.equals(a+b));//true
System.out.println(g==(a+b));//true
System.out.println(g.equals(a+b));//false
System.out.println(g.equals(a+h));//true
}
}
解释:
第一条: 当" == “运算符的两个操作数都是包装器类型,则是比较指向的是否是同一个对象。3 < 127,是同一个对象。
第二条: 当” == “运算符的两个操作数都是包装器类型,则是比较指向的是否是同一个对象。321 > 127,不是同一个对象。
第三条: 当”==" 两边有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)。由于 a+b包含了算术运算,因此会触发自动拆箱过程(会调用intValue方法),因此它们比较的是数值是否相等。
第四条: 对于c.equals(a+b)会先触发自动拆箱过程,再触发自动装箱过程,也就是说a+b,会先各自调用intValue方法,得到了加法运算后的数值之后,便调用Integer.valueOf方法,再进行equals比较,而且泛型一样会比较值
第五条: 同第三条。
第六条: g是Long类型,a+b是Integer类型,泛型不一样。
第七条: 会先触发自动拆箱过程,再触发自动装箱过程,a会调用intValue方法,h调用longValue方法,得到了加法运算后的数值之后,便调用Long.valueOf方法,再进行equals比较。g是Long类型,a+b也是Long类型,泛型一样比较值。
总结:
1、Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。Double、Float的valueOf方法的实现是类似的。
2、对于包装器类型的equals()方法不能单纯的说比较的是值,而是在满足泛型的条件下才比较值。
3、当 "=="运算符的两个操作数都是 包装器类型的引用,则是比较指向的是否是同一个对象,而如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)。另外,对于包装器类型,equals方法并不会进行类型转换。