一、"=="和equals()的区别
“==”
- 在比较两个对象时,比较的是对象的地址
- 即使是直接使用"= ="操作符(“aa”==“aa”),比较的还是两个字符串的引用地址
“equals()”
- 如果没有重写equals()方法比较的是对象的地址
- 重写方法后比较的是内容(大多数方法都重写)
- 我们都知道我们使用的类都是继承自Object基类,Object中equals方法中是使用==来实现的,即比较的是两者的地址值。但是Object的子类可以重写equals方法,比如Date、String、Integer等类都是重写了equals都是重写了,比较的是值是否相等。https://blog.csdn.net/qq_26947195/article/details/79505553
那么,怎样比较对象的地址呢?
二、常量池
Integer a = new Integer(1);
Integer b = new Integer(1);
System.out.println(a==b); //false
Integer c = 1;
Integer d = 1;
System.out.println(c==d); //true
为什么两个结果不同呢?
常量池在java用于保存在编译期已确定的,已编译的class文件中的一份数据。它包括了关于类,方法,接口等中的常量,也包括字符串常量,如String s = "java"这种申明方式;当然也可扩充,执行器产生的常量也会放入常量池,故认为常量池是JVM的一块特殊的内存空间。
参考文章:https://www.cnblogs.com/syp172654682/p/8082625.html
1 String s1 = "Hello";
2 String s2 = "Hello";
3 String s3 = "Hel" + "lo";
4 String s4 = "Hel" + new String("lo");
5 String s5 = new String("Hello");
6 String s6 = s5.intern();
7 String s7 = "H";
8 String s8 = "ello";
9 String s9 = s7 + s8;
10
11 System.out.println(s1 == s2); // true
12 System.out.println(s1 == s3); // true
13 System.out.println(s1 == s4); // false
14 System.out.println(s1 == s9); // false
15 System.out.println(s4 == s5); // false
16 System.out.println(s1 == s6); // true
s1 == s2这个非常好理解,s1、s2在赋值时,均使用的字符串字面量,说白话点,就是直接把字符串写死,在编译期间,这种字面量会直接放入class文件的常量池中,从而实现复用,载入运行时常量池后,s1、s2指向的是同一个内存地址,所以相等。
s1 = = s3这个地方有个坑,s3虽然是动态拼接出来的字符串,但是所有参与拼接的部分都是已知的字面量,在编译期间,这种拼接会被优化,编译器直接帮你拼好,因此String s3 = “Hel” + “lo”;在class文件中被优化成String s3 = “Hello”,所以s1 == s3成立。只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。
s1 == s4当然不相等,s4虽然也是拼接出来的,但new String(“lo”)这部分不是已知字面量,是一个不可预料的部分,编译器不会优化,必须等到运行时才可以确定结果,结合字符串不变定理,鬼知道s4被分配到哪去了,所以地址肯定不同。对于所有包含new方式新建对象(包括null)的“+”连接表达式,它所产生的新对象都不会被加入字符串池中。
s1 == s9也不相等,道理差不多,虽然s7、s8在赋值的时候使用的字符串字面量,但是拼接成s9的时候,s7、s8作为两个变量,都是不可预料的,编译器毕竟是编译器,不可能当解释器用,不能在编译期被确定,所以不做优化,只能等到运行时,在堆中创建s7、s8拼接成的新字符串,在堆中地址不确定,不可能与方法区常量池中的s1地址相同。
s1 == s6这两个相等完全归功于intern方法,s5在堆中,内容为Hello ,intern方法会尝试将Hello字符串添加到常量池中,并返回其在常量池中的地址,因为常量池中已经有了Hello字符串,所以intern方法直接返回地址;而s1在编译期就已经指向常量池了,因此s1和s6指向同一地址,相等。
关于intern:intern方法会返回String对象在常量池中的引用,如果在常量池中已经存在这个字符串了,那么直接返回这个引用;如果没有,就把这个字符串复制到常量池,然后返回引用。
String a = new String("A");
String a1 = "A";
System.out.println(a==a1); //false
System.out.println(a1.intern()==a); //false
System.out.println(a.intern()==a1); //true
特例1
public static final String A = "ab"; // 常量A
public static final String B = "cd"; // 常量B
public static void main(String[] args) {
String s = A + B; // 将两个常量用+连接对s进行初始化
String t = "abcd";
if (s == t) {
System.out.println("s等于t,它们是同一个对象");
} else {
System.out.println("s不等于t,它们不是同一个对象");
}
}
s等于t,它们是同一个对象
对比上面的s1==s9,同样是拼接的,为什么这里将A和B拼接起来就相等呢?
A和B都是常量,值是固定的,因此s的值也是固定的,它在类被编译时就已经确定了。也就是说:String s=A+B; 等同于:String s=“ab”+“cd”;
常量
https://blog.csdn.net/qq_26947195/article/details/79505553
第一种:是一个值,这个值本身,我们就叫做常量。
整型常量:1024
实型常量:1.024
字符常量:‘g’ ‘c’ ‘w’
字符串常量:“gcw”
逻辑常量:true false
这只是我们平时我们的一个说法而已,比如数字1024,我们说它是一个int类型的常量。
第二种:不可变的变量,我们也称为常量。就是被我们都知道的关键字final修饰的变量,final修饰的变量,只要一经赋值,就不可以改变。可能它本身是个变量,但是被final修饰,我们可以认为是个常量。比如:
final int i=1024;
特例2
public static final String A; // 常量A
public static final String B; // 常量B
static {
A = "ab";
B = "cd";
}
public static void main(String[] args) {
// 将两个常量用+连接对s进行初始化
String s = A + B;
String t = "abcd";
if (s == t) {
System.out.println("s等于t,它们是同一个对象");
} else {
System.out.println("s不等于t,它们不是同一个对象");
}
}
s不等于t,它们不是同一个对象
A和B虽然被定义为常量,但是它们都没有马上被赋值。在运算出s的值之前,他们何时被赋值,以及被赋予什么样的值,都是个变数。因此A和B在被赋值之前,性质类似于一个变量。那么s就不能在编译期被确定,而只能在运行时被创建了。