Java中“==”与equals()

1 前言

1.1 内存分区

Java中有6种存储区域（参考Java的六大存储区域），如下：

1. 寄存器（register）：位于处理器内部，处理速度最快，空间比较珍贵；
2. 栈（stack）：位于通用RAM中，处理速度仅次于寄存器，空间较小。常用于存放对象引用、基本类型数据、方法调用；
3. 堆（heap）：位于通用RAM中，空间较大，常用于存放对象；
4. 静态存储（static）：用关键字static来标识一个对象的特定元素是静态的，但对象不会存放在静态存储空间里；
5. 常量池（constant）：Java中常量共有5类：整型常量、浮点型常量、布尔型常量、字符型常量、字符串常量。使用final可定义符号常量，一经赋值，不能修改；
6. 非RAM存储：存活于程序之外，不受程序控制的数据，在程序没有运行时也可以存在。如：流对象和持久化对象。

1.2 “==”的应用

• 对于基本类型数据，表示对值进行比较（本质还是比较地址）；

基本类型数据存放在栈上，栈具有共享性。比如：int i = 0; int j = 0; i 和 j 共同指向值为0的内存区，当 i 改变时，如 i = 1，i 指向了新的内存区，并没有改变 j 的值。

• 对于引用数据类型，表示对地址（引用指向的对象地址）进行比较；

1.3 equals() 的应用及源码分析

• Object类中，表示对地址进行比较；

public boolean equals(Object obj) {
    return (this == obj);
}

• String、Integer、Float、Double、Boolean类中重写了equals() 方法，表示对值进行比较；

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;
}

Integer:
public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

Float:
public boolean equals(Object obj) {
    return (obj instanceof Float)
            && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
}

Double：
public boolean equals(Object obj) {
    return (obj instanceof Double)
            && (doubleToLongBits(((Double)obj).value) == doubleToLongBits(value));
}

Boolean:
public boolean equals(Object obj) {
    if (obj instanceof Boolean) {
        return value == ((Boolean)obj).booleanValue();
    }
    return false;
}

• Character类中，使用final修饰了equals() 方法，表示比较值（具体啥原因笔者也不太明白，知道的读者请留言）。

public final boolean equals(Object obj) {
    return (this == obj);
}

• 用户自定义类中，若不重写equals() 方法，表示对地址进行比较；如果想表示对对象内的属性进行比较，可以重写equals() 方法。

2 实验验证

2.1 基本类型数据

为方便打印变量地址，笔者参考了java中打印变量地址，主要调用printAddresses() 方法，

public static void basic() {
    int i=0;
    printAddresses("i-0",i);
    int j=0;
    printAddresses("j-0",j);
    i=1;
    printAddresses("i-1",i);
    printAddresses("j-0",j);
}

i-0: 0x6afbe3300
j-0: 0x6afbe3300
i-1: 0x6afbe3380
j-0: 0x6afbe3300

刚开始 i 和 j 都等于0，指向同一个常量，所有地址一样；当 i=1 时，i 指向了新的常量，地址也更换了，但不影响 j 的地址。

这里给出一个逆天的例子，如下：

public static void basic() {
    printAddresses("-128",-128); //0x6afbdf300
    printAddresses("-128",-128); //0x6afbdf300
    printAddresses("127",127);   //0x6afbe7280
    printAddresses("127",127);   //0x6afbe7280

    printAddresses("-129",-129); //0x6afe89800
    printAddresses("-129",-129); //0x6afe8a400
    printAddresses("128",128);   //0x6afe8b180
    printAddresses("128",128);   //0x6afe8bd80
}

通过多次实验发现，只有-128~127之间的常量，相同值地址也相同，超出此范围的常量，内存地址不同。

2.2 String类

public static void string() {
	String s1 = "abc";
	String s2 = "abc";
	String s3 = new String("abc");
	String s4 = new String("abc");

	System.out.println(s1==s2); //true
	System.out.println(s1==s3); //false
	System.out.println(s3==s4); //false

	System.out.println(s1.equals(s2)); //true
	System.out.println(s1.equals(s3)); //true
	System.out.println(s3.equals(s4)); //true
}

内存状态图

字符串常量存储在字符串常量池中，由于String是不可变类，一旦创建好了就不能修改，因此String对象可以被共享而不会导致程序的混乱。

当创建一个字符串常量时，首先在字符串常量池中查找是否已经有相同的字符串被定义，若已经被定义，则直接获取其引用，此时不需要再创建对象；若没有定义，则创建该对象，然后把它加入到字符串常量池中，再将它的引用返回。所以s1和s2指向的常量池中同一字符串对象。

new String("abc") <==> "abc" 和 new String()两个操作，若在字符串常量池中不存在 "abc" ，则会创建一个字符串常量 "abc" ，并将其添加到字符串常量池中；若存在，则不创建。然后 new String() 会在堆中创建一个新的对象，并引用字符串常量 "abc"。即 new String("abc") 可能会创建1个或2个对象（取决于常量池中原来是否有字符串"abc"）。所以s3和s4指向的对象不同。

2.3 Integer类

public static void integer() {
        int i0=123;
	Integer i1=123;
	Integer i2=123;
	Integer i3=new Integer(123);
	Integer i4=new Integer(123);

	System.out.println(i0==i1); //true
	System.out.println(i1==i2); //true
	System.out.println(i1==i3); //false
	System.out.println(i3==i4); //false

	System.out.println(i1.equals(i0)); //true
	System.out.println(i1.equals(i2)); //true
	System.out.println(i1.equals(i3)); //true
	System.out.println(i3.equals(i4)); //true
}

Float、Double、Boolean、Character类测试结果一样。

注意：Integer 类中，只有-128~127之间的常量，相同值地址也相同，超出此范围的常量，内存地址不同。笔者追了下源码，发现Integer.valueOf() 方法中设置了常量池的界限，如下：

static final int low = -128;
static final int high=127;
static final Integer cache[];

public static Integer valueOf(int i) {
     if (i >= IntegerCache.low && i <= IntegerCache.high)
         return IntegerCache.cache[i + (-IntegerCache.low)];
     return new Integer(i);
}

2.4 自定义类Cat

class Cat {
	String name;
	Integer age;

	Cat(String name,Integer age){
		this.name=name;
		this.age=age;
	}

	public boolean equals(Cat cat) {
		if (name.equals(cat.name) && age.equals(cat.age)) {
			return true;
		}
		return false;
	}
}

public static void cat() {
	Cat cat1=new Cat("Tom",1);
	Cat cat2=new Cat("Tom",1);
	Cat cat3=new Cat(new String("Tom"),new Integer(1));
	Cat cat4=new Cat(new String("Tom"),new Integer(1));

	System.out.println(cat1==cat2); //false
	System.out.println(cat1==cat3); //false
	System.out.println(cat3==cat4); //false
	System.out.println(cat1.name==cat2.name); //true
	System.out.println(cat1.name==cat3.name); //false
	System.out.println(cat3.name==cat4.name); //false
	System.out.println(cat1.age==cat2.age); //true
	System.out.println(cat1.age==cat3.age); //false
	System.out.println(cat3.age==cat4.age); //false

	System.out.println(cat1.equals(cat2)); //true
	System.out.println(cat1.equals(cat3)); //true
	System.out.println(cat3.equals(cat4)); //true
	System.out.println(cat1.name.equals(cat2.name)); //true
	System.out.println(cat1.name.equals(cat3.name)); //true
	System.out.println(cat3.name.equals(cat4.name)); //true
	System.out.println(cat1.age.equals(cat2.age)); //true
	System.out.println(cat1.age.equals(cat3.age)); //true
	System.out.println(cat3.age.equals(cat4.age)); //true
}

​ 声明：本文转自Java中“==”与equals()