==操作符
对于8种基本类型(即boolean/char/byte/short/int/long/float/double):比较两个变量的值是否相等;
对于引用类型(即除去8种基本类型外的其他所有类型):比较两个变量的引用内存地址是否相等。
equals()方法
Object类中的默认实现是直接用==的,也就是比较this和obj的引用内存地址是否相等。
public boolean equals(Object obj) {
return (this == obj);
}
但是在多数情况下,==的实现方式显然不是我们想要的,因此equals()方法往往会被覆写为比较两个引用的内容。比如String类中的equals()方法如下。
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()方法必须具有如下几个特性:
- 自反性:对非空引用x,x.equals(x)恒为true;
- 对称性:对任意引用x和y,若x.equals(y)为true,那么y.equals(x)也为true;
- 传递性:对任意引用x、y、z,若x.equals(y)与y.equals(z)都为true,那么x.equals(z)也为true;
- 一致性:如果引用x和y引用的对象没有发生变化,那么x.equals(y)应一直返回同样的结果;
- 对非空引用x,x.equals(null)恒为false。
举个栗子
以整形为例。
int i1 = 200;
Integer i2 = 200;
Integer i3 = 200;
Integer i4 = new Integer(200);
System.out.println(i1 == i2); // true
System.out.println(i2 == i3); // false
System.out.println(i3 == i4); // false
System.out.println(i3.equals(i4)); // true
返回结果是true、false、false、true。为什么会是这样?
执行javap -c EqualsExample.class
命令,查看字节码如下。
0: sipush 200
3: istore_1
4: sipush 200
7: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
10: astore_2
11: sipush 200
14: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
17: astore_3
18: new #3 // class java/lang/Integer
21: dup
22: sipush 200
25: invokespecial #4 // Method java/lang/Integer."":(I)V
28: astore 4
30: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
33: iload_1
34: aload_2
35: invokevirtual #6 // Method java/lang/Integer.intValue:()I
38: if_icmpne 45
41: iconst_1
42: goto 46
45: iconst_0
46: invokevirtual #7 // Method java/io/PrintStream.println:(Z)V
49: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
52: aload_2
53: aload_3
54: if_acmpne 61
57: iconst_1
58: goto 62
61: iconst_0
62: invokevirtual #7 // Method java/io/PrintStream.println:(Z)V
65: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
68: aload_3
69: aload 4
71: if_acmpne 78
74: iconst_1
75: goto 79
78: iconst_0
79: invokevirtual #7 // Method java/io/PrintStream.println:(Z)V
82: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
85: aload_3
86: aload 4
88: invokevirtual #8 // Method java/lang/Integer.equals:(Ljava/lang/Object;)Z
91: invokevirtual #7 // Method java/io/PrintStream.println:(Z)V
由上可见,i2与i3的赋值过程都触发了自动装箱,也就是将基本类型int自动转化成了对应的包装类Integer,调用Integer.valueOf()方法。而i4这种显式new的写法完全没有必要,只是拉出来做对比而已。
- i1 == i2为true
在基本类型与包装类做比较时,包装类会先自动拆箱,也就是执行了Integer.intValue()方法,所以最终变为两个值相同的int比较,自然为真。同样地,如果包装类要进行运算,也会先自动拆箱,因为Java的数学运算全部在栈上进行,+、-等操作符不适用于包装类。
- i2 == i3为false
看一看Integer.valueOf()方法的源码。
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() {}
}
可见,IntegerCache正如其名,是一个整形缓存类,其中的cache数组默认缓存了[-128, 127]之间的数。如果调用valueOf()时的参数i恰好在这个区间内,那么就会直接返回cache数组中的对应值,否则就会再new一个Integer对象出来。
除Integer之外,非浮点型其他包装类Byte、Short、Long等也都有类似的缓存机制。JDK认为[-128, 127]区间内的整形值可能非常常用,因此将它们缓存下来可以提高效率。这种机制在Java规范中还有一个更通用的名字,叫做常量池(constant pool)。
上面示例中的取值200不在这个区间内,因此i2和i3是分别new出来的两个对象,它们在堆内存中的地址不同,故i2 == i3为假。假若取值为100,那么它们的地址相同,i2 == i3就会为真。
在这里回忆一下JVM内存模型的相关知识:
基本类型的数据是存放在Java虚拟机栈中的局部变量表里。这里除了基本类型外,还有reference类型和returnAddress类型。reference就是对象的引用,可以认为包含了对象的起始内存地址。所有对象实例(也就是所谓new出来的东西)和数组则是存放在Java堆里,也是GC发生的主要区域。
- i3 == i4为false
这就是很自然的了,它们两个在堆内存中的地址也是不同的。
- i3.equals(i4)为true
看一下Integer.equals()方法的源码。
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
很简单,就是将两个Integer拆箱成int然后比较值。这也是我们真正需要的方法。
如果换成String呢
String s1 = "LittleMagic";
String s2 = new String("LittleMagic");
String s3 = s2;
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // true
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // true
这里如果再展开讲的话,就会涉及到String常量池与String.intern()等东西的细节。字符串本身就是一个复杂的话题,为了避免本文篇幅过长,应该专门另写一篇文章来记录了。