1. 用 == 进行比较:
基本数据类型. 例 byte,short,int,long,float,double,boolean.char,比较的是他们的值。
引用数据类型,比较的是他们在内存中存放的地址,所以,除非是同一个 new 出来的对象,否则他们比较的结果就为false.
2. 用 equals() 进行比较:
JAVA中的所有类都是继承于Object这个基类的,在Object 类中定义了一个equals方法,这个方法的初始行为是比较对象的内存地址,
但在一些类库当中这个方法被重写,如String,Integer,Date在这些类当中equals有其自身的实现,而不再是比较类在内存中的地址值了。
引用数据类型,有两种情况:
1. 没有重写equals,他们之间比较的还是内存中的地址值.
2. 重写了equals,他们之间比较的就不是地址值了,根据具体业务来定义该方法,有可能是对象的内容了。
3. 引入概念来解释。
1. 字符串缓冲池。
在程序运行时虚拟机会创建一个字符串缓冲池,当使用 s2 = "Monday" 这样的表达式创建字符串时,程序会先在字符缓冲池中寻找相同的对象。
在第一个程序中,s1 先被放入池中,当 s2 被创建时,程序找到了具有相同值的 s1,就让 s2 去引用 s1引用的对象,两个引用指向了同一个对象。
在第二个程序中,使用了 new 操作符,他告诉程序: 我不要旧的,我要自己创建一个新的,于是一个新的"Monday"Sting对象被创建在内存中。
他们的值相同,但是位置不同。
4. 总结:
equals() 和 == 区别有:
1. equals() 是方法. == 是操作符。
2. == 主要用于基本类型之间的比较, 有时也比较对象,而 equals() 仅用于对象之间的比较。
例 1: 用 equals() 进行比较,重写了 equals方法
class Test
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
String s1 = "Monday";
String s2 = "Monday";
sop(s1==s2); //比较的是内存地址值
sop(s1.equals(s2)); // 重写了 String 类中的 equals 方法,比较的是对象的内容
}
}
运行结果: true
true
例 2: 用 equals() 进行比较,重写了 equals方法
class Test
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
String s1 = new String();
String s2 = new String();
sop(s1==s2); //比较的是内存地址
sop(s1.equals(s2)); // 重写了 String 类中的 equals 方法,比较的是对象的内容
s1=s2;
sop(s1==s2);
sop(s1.equals(s2));
}
}
运行结果: false
true
true
true
例 3: 用 equals() 进行比较,没有重写equals方法
class Test
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Object s1 = new Object();
Object s2 = new Object();
sop(s1==s2); //比较的是内存地址
sop(s1.equals(s2)); // 比较的是内存地址,因为此处的 equals 方法还是用的 Object 类中的 equals 方法。
s1=s2;
sop(s1==s2);
sop(s1.equals(s2));
}
}
运行结果: false
false
true
true
例 4:
class Test
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
String s1 = "Monday";
String s2 = new String("Monday");
s2 = s2.intern();
sop(s1==s2);
sop(s1.equals(s2));
}
}
运行结果: true
true
范例分析:
java.lang.String的intern()方法 ,检查字符串池里是否存在"abc"这么一个字符串(用 equals(Object) 方法确定),如果存在,就返回池里的字符串;
如果不存在,该方法会把"abc"添加到字符串池中,然后再返回它的引用。
intern遵循以下规则:对于任意两个字符串 s 和 t,当且仅当 s.equals(t) 为 true 时,s.intern() == t.intern() 才为 true。
更好的办法: 把所有的 String 都 intern() 到缓冲池去,在用到new的时候就进行这个操作,String s2 = new String("Monday").intern();
例 5 :用 equals() 进行比较,没有重写equals方法
class Test
{
public static void main(String[] args)
{
A a1 = new A();
a1.age = 10;
a1.home = "浙江";
A a2 = new A();
a2.age = 10;
a2.home = "浙江";
System.out.println(a1==a2);
System.out.println(a1.equals(a2)); // A类没有重写equals方法,还是沿用的 Object 中的 equals ,所以比较的是地址。
}
}
class A
{
int age;
String home;
}
运行结果: false
false
例 6 :接上面的例子,用 equals() 进行比较,重写了 equals 方法
class Test
{
public static void main(String[] args)
{
A a1 = new A();
a1.age = 10;
a1.home = "浙江";
A a2 = new A();
a2.age = 10;
a2.home = "浙江";
System.out.println(a1==a2);
System.out.println(a1.equals(a2));
}
}
class A
{
int age;
String home;
//重写了 equals 方法
public boolean equals(Object obj)
{
//为空false,类型不一致false,各个成员变量值相等才为true
if(obj==null)
{
return false;
}
else
{
if(! (obj instanceof A))
{
return false;
}
else
{
A a = (A)obj;//强转
if(a.age==this.age && a.home.equals(this.home))
{
return true;
}
return false;
}
}
}
}
运行结果: false
true
|