1 前言
1.1 内存分区
Java中有6种存储区域（参考Java的六大存储区域），如下：
- 寄存器（register）：位于处理器内部，处理速度最快，空间比较珍贵；
- 栈（stack）：位于通用RAM中，处理速度仅次于寄存器，空间较小。常用于存放对象引用、基本类型数据、方法调用；
- 堆（heap）：位于通用RAM中，空间较大，常用于存放对象；
- 静态存储（static）：用关键字static来标识一个对象的特定元素是静态的，但对象不会存放在静态存储空间里；
- 常量池（constant）：Java中常量共有5类：整型常量、浮点型常量、布尔型常量、字符型常量、字符串常量。使用final可定义符号常量，一经赋值，不能修改；
- 非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
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
