字符 解决 ignorecas bsp 快速 并不是 比较 htm
为什么 equals() 方法要重写?
判断两个对象在逻辑上是否相等,如根据类的成员变量来判断两个类的实例是否相等,而继承 Object 中的 equals 方法只能判断两个引用变量是否是同一个对象。这样我们往往需要重写 equals() 方法。
我们向一个没有重复对象的集合中添加元素时,集合中存放的往往是对象,我们需要先判断集合中是否存在已知对象,这样就必须重写 equals 方法。
怎样重写 equals() 方法?
重写 equals 方法的要求:
1、自反性:对于任何非空引用 x,x.equals(x) 应该返回 true。
2、对称性:对于任何引用 x 和 y,如果 x.equals(y) 返回 true,那么 y.equals(x) 也应该返回 true。
3、传递性:对于任何引用 x、y 和 z,如果 x.equals(y) 返回 true,y.equals(z) 返回 true,那么 x.equals(z) 也应该返回 true。
4、一致性:如果 x 和 y 引用的对象没有发生变化,那么反复调用 x.equals(y) 应该返回同样的结果。
5、非空性:对于任意非空引用 x,x.equals(null) 应该返回 false。
1、自反性原则
在 JavaBean 中,经常会覆写 equals 方法,从而根据实际业务情况来判断两个对象是否相等,比如我们写一个 person 类,根据姓名来判断两个 person 类实例对象是否相等。代码如下:
- 1 public class Person {
- 2 private String name;
- 3 4 public Person(String name) {
- 5 this.name = name;
- 6
- }
- 7 8 public String getName() {
- 9
- return name;
- 10
- }
- 11 12 public void setName(String name) {
- 13 this.name = name;
- 14
- }
- 15 16@Override 17 public boolean equals(Object obj) {
- 18
- if (obj instanceof Person) {
- 19 Person person = (Person) obj;
- 20
- return name.equalsIgnoreCase(person.getName().trim());
- 21
- }
- 22
- return false;
- 23
- }
- 24 25 public static void main(String[] args) {
- 26 Person p1 = new Person("张三");
- 27 Person p2 = new Person("张三 ");
- 28 List list = new ArrayList();
- 29 list.add(p1);
- 30 list.add(p2);
- 31 System.out.println("是否包含张三:" + list.contains(p1));
- 32 System.out.println("是否包含张三:" + list.contains(p2));
- 33
- }
- 34
- }
list 中含有这个生成的 person 对象,结果应该为 true,但是实际结果:这里考虑了字符串空格的问题,去除前后的空格。
是否包含张三:true
是否包含张三:false
第二个为什么会是 false 呢?
原因在于 list 中检查是否含有元素时是通过调用对象的 equals 方法来判断的,也就是说 contains(p2)传递进去会依次执行 p2.equals(p1)、p2.equals(p2),只要一个返回 true,结果就是 true。但是这里 p2.equals(p2) 返回的是 false?由于我们对字符前后进行了空格的切割造成 p2.equals(p2) 的比较实际上是:"张三".equals("张三"),一个有空格,一个没有空格就出错了。
这个违背了 equals 的自反性原则:对于任何非空引用 x,x.equals(x) 应该返回 true。
这里只要去掉 trim 方法就可以解决。
2、对称性原则
上面这个例子,还并不是很好,如果我们传入 null 值,会怎么样呢?增加一条语句:Person p2=new Person(null);
结果:
- 是否包含张三:true
- Exception in thread "main" java.lang.NullPointerException//空指针异常
原因在执行 p2.equals(p1) 时,由于 p2 的 name 是一个 null 值,所以调用 name.equalsIgnoreCase() 方法时就会报空指针异常。
这是在覆写 equals 方法时没有遵循对称性原则:对于任何应用 x,y 的情形,如果想 x.equals(y) 返回 true,那么 y.equals(x), 也应该返回 true。
应该在 equals 方法里加上是否为 null 值的判断:
- 1@Override 2 public boolean equals(Object obj) {
- 3
- if (obj instanceof Person) {
- 4 Person person = (Person) obj;
- 5
- if (person.getName() == null || name == null) {
- 6
- return false;
- 7
- } else {
- 8
- return name.equalsIgnoreCase(person.getName());
- 9
- }
- 10
- }
- 11
- return false;
- 12
- }
3、传递性原则
现在我们有一个 Employee 类继承自 person 类:
- 1 public class Employee extends Person {
- 2 private int id;
- 3 4 5 public int getId() {
- 6
- return id;
- 7
- }
- 8 public void setId(int id) {
- 9 this.id = id;
- 10
- }
- 11 public Employee(String name, int id) {
- 12 super(name);
- 13 this.id = id;
- 14 // TODO Auto-generated constructor stub
- 15
- }
- 16@Override 17 public boolean equals(Object obj) {
- 18
- if (obj instanceof Employee) {
- 19 Employee e = (Employee) obj;
- 20
- return super.equals(obj) && e.getId() == id;
- 21
- }
- 22
- return super.equals(obj);
- 23
- }
- 24 25 public static void main(String[] args) {
- 26 Employee e1 = new Employee("张三", 12);
- 27 Employee e2 = new Employee("张三", 123);
- 28 Person p1 = new Person("张三");
- 29 30 System.out.println(p1.equals(e1));
- 31 System.out.println(p1.equals(e2));
- 32 System.out.println(e1.equals(e2));
- 33
- }
- 34
- }
只有在 name 和 ID 都相同的情况下才是同一个员工,避免同名同姓的。在 main 里定义了,两个员工和一个社会闲杂人员,虽然同名同姓但肯定不是同一个人。运行结果应该三个都是 false 才对。但是:
true
true
false
p1 尽然等于 e1, 也等于 e2,不是同一个类的实例也相等了?
因为 p1.equals(e1) 是调用父类的 equals 方法进行判断的它使用 instanceof 关键字检查 e1 是否是 person 的实例,由于 employee 和 person 是继承关系,结果就是 true 了。但是放过来就不成立,e1,e2 就不等于 p1,这也是违反对称性原则的一个典型案例。
e1 竟然不等于 e2?
e1.equals(e2) 调用的是 Employee 的 equals 方法,不仅要判断姓名相同还有判断工号相同,两者的工号不同,不相等时对的。但是 p1 等于 e1, 也等于 e2,e1 却不等于 e2,这里就存在矛盾,等式不传递是因为违反了 equals 的传递性原则:对于实例对象 x、y、z;如果 x.equals(y) 返回 true,y.equals(z) 返回 true,那么 x.equals(z) 也应该返回 true。
上述情况会发生是因为父类使用 instanceof 关键字 (是否是这个特定类或者是它的子类的一个实例),用来判断是否是一个类的实例对象的,这很容易让子类 "钻空子"。
想要解决也很简单,使用 getClass 进行类型的判断,person 类的 equals 方法修改如下:
- 1@Override 2 public boolean equals(Object obj) {
- 3
- if (obj != null && obj.getClass() == this.getClass()) {
- 4 Person person = (Person) obj;
- 5
- if (person.getName() == null || name == null) {
- 6
- return false;
- 7
- } else {
- 8
- return name.equalsIgnoreCase(person.getName());
- 9
- }
- 10
- }
- 11
- return false;
- 12
- }
4、必须覆写 hashCode 方法这样结果就是三个 false。
覆写 equals 方法就必须覆写 hashCode 方法,这是 Javaer 都知道的。
原因就是 HashMap 的底层处理机制是以数组的方式保存 map 条目的,这其中的关键是这个数组下标的处理机制:
依据传入元素的 hashCode 方法的返回值决定其数组的下标,如果该数组位置上已经有了 map 条目,且与传入的键值相等则不处理,若不相等则覆盖;如果数组位置没有条目,则插入,并加入到 map 条目的链表中。同理检查键是否存在也是根据哈希吗确定文职,然后遍历查找键值的。
那么对象的 hashCode 方法返回的是什么呢?
他是一个对象的哈希码,是有 Object 类的本地方法生成的,确保每个对象有一个哈希码。
1、重写 equals 方法实例 部分代码参考 http://blog.csdn.net/wangloveall/article/details/7899948
重写 equals 方法的目的是判断两个对象的内容 (内容可以有很多,比如同时比较姓名和年龄,同时相同的才是用一个对象) 是否相同。
如果不重写 equals,那么比较的将是对象的引用是否指向同一块内存地址,重写之后目的是为了比较两个对象的 value 值是否相等。特别指出利用 equals 比较八大包装对象,(如 int,float 等)和 String 类(因为该类已重写了 equals 和 hashcode 方法)对象时,默认比较的是值,在比较其它自定义对象时都是比较的引用地址。
- package com.lk.C;
- class User {
- private String name;
- private int age;
- public int getAge() {
- return age;
- }
- public voidsetAge(int age) {
- this.age = age;
- }
- public void setName(String name) {
- this.name = name;
- }
- public String getName() {
- return name;
- }
- public boolean equals(Object obj) {
- if(this== obj) {
- return true;
- }
- if(null== obj) {
- return false;
- }
- if(this.getClass() != obj.getClass()) {
- return false;
- }
- User user = (User) obj;
- if(this.name.equals(user.name)&&this.age == user.age) {
- return true;
- }
- return false;
- }
- }
- public class Test6 {
- public static void main(String[] args) {
- User userA =new User();
- userA.setName("王明");
- userA.setAge(10);
- User userB =new User();
- userB.setName("王明");
- userB.setAge(10);
- User userC =new User();
- userC.setName("王亮");
- userC.setAge(10);
- System.out.println("userA equals userB:" + userA.equals(userB));
- System.out.println("userA equals userC:" + userA.equals(userC));
- }
- }
- userA equals userB:true
- userA equals userC:false
在 Java 中,问什么说重写了 equals 方法都要进而重写 Hashcode 方法呢?
原因如下:当 equals 此方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码。如下:
(1) 当 obj1.equals(obj2) 为 true 时,obj1.hashCode() == obj2.hashCode() 必须为 true
(2) 当 obj1.hashCode() == obj2.hashCode() 为 false 时,obj1.equals(obj2) 必须为 false
hashcode 是用于散列数据的快速存取,如利用 HashSet/HashMap/Hashtable 类来存储数据时,都是根据存储对象的 hashcode 值来进行判断是否相同的。
这样如果我们对一个对象重写了 euqals,意思是只要对象的成员变量值都相等那么 euqals 就等于 true,但不重写 hashcode,那么我们再 new 一个新的对象,当原对象. equals(新对象)等于 true 时,两者的 hashcode 却是不一样的,由此将产生了理解的不一致。
2、看看下面的三段程序
- package com.lk.C;
- public class Test7 {
- public static void main(String[] args) {
- inta = 10;
- intb = 10;
- System.out.print("基本类型a==b:");
- System.out.println(a == b);
- System.out.println("-----");
- String s1 = "abc";
- String s2 = "abc";
- System.out.print("String类型是s1==s2:");
- System.out.println(s1 == s2);
- System.out.println("-----");
- String s3 =newString("abc");
- String s4 =newString("abc");//可以看出==比较的是栈的地址是否相同System.out.print("String类型用new String()是s1==s2:");
- System.out.println(s3 == s4);
- System.out.println(s1 == s3);
- System.out.println("-----");
- Integer i1 = 1;
- Integer i2 = 1;
- System.out.print("包装类型是i1==i2:");
- System.out.println(i1 == i2);
- System.out.println("-----");
- Integer i3 = 128;
- Integer i4 = 128;//此时输出false是因为Integer在-128-127之间会缓存,超出这个范围就不会缓存了System.out.print("包装类型是i3==i4:");
- System.out.println(i3 == i4);
- System.out.println("-----");
- Integer i5 =newInteger("1");
- Integer i6 =newInteger("1");
- System.out.print("包装类型用new Integer()是i5==i6:");
- System.out.println(i5 == i6);//用new Integer()多少都不会缓存System.out.println("-----");
- A a1 =newA(1);
- A a2 =newA(1);
- A a3 = a2;
- System.out.print("普通引用类型a1 == a2:");
- System.out.println(a1 == a2);
- System.out.println(a2 == a3);//对象赋给新对象连地址都是相同的System.out.println("-----");
- }
- }
- class A{
- int i;
- publicA(int i){
- this.i = i;
- }
- }
- 基本类型a==b:true-----
- String类型是s1==s2:true-----
- String类型用new String()是s1==s2:false
- false-----
- 包装类型是i1==i2:true-----
- 包装类型是i3==i4:false-----
- 包装类型用new Integer()是i5==i6:false-----
- 普通引用类型a1 == a2:false
- true-----
- package com.lk.C;
- public class Test8 {
- public static void main(String[] args) {
- // TODO Auto-generated method stubSystem.out.println("基本类型没有equals方法");
- System.out.println("-----");
- String s1 = "abc";
- String s2 = "abc";
- System.out.print("String类型的equals方法:");
- System.out.println(s1.equals(s2));
- System.out.println("-----");
- String s3 =newString("abc");
- String s4 =newString("abc");//可以看出比较equals方法比较的是堆里的值是否相同System.out.print("String类型的new String()的equals方法:");
- System.out.println(s3.equals(s4));
- System.out.println("-----");
- System.out.print("String用==赋值和用new String()赋值的比较:");
- System.out.println(s1.equals(s3));
- System.out.println("-----");
- Integer i1 = 1;
- Integer i2 = 1;
- System.out.print("包装类的equals方法:");
- System.out.println(i1.equals(i2));
- System.out.println("-----");
- Integer i3 =newInteger(1);
- Integer i4 =newInteger(1);
- System.out.print("包装类的new Integer()用equals方法:");
- System.out.println(i3.equals(i4));
- System.out.println("-----");
- System.out.print("Integer用==赋值和用new Integer()赋值的比较:");
- System.out.println(i1.equals(i3));
- System.out.println("-----");
- }
- }
- 基本类型没有equals方法
- -----
- String类型的equals方法:true-----
- String类型的new String()的equals方法:true-----
- String用==赋值和用new String()赋值的比较:true-----
- 包装类的equals方法:true-----
- 包装类的new Integer()用equals方法:true-----
- Integer用==赋值和用new Integer()赋值的比较:true-----
- package com.lk.C;
- public class Test9 {
- public static void main(String[] args) {
- // TODO Auto-generated method stubStudent s1 =newStudent("阿坤",21);
- Student s2 =newStudent("阿坤",21);
- Student s3 =new Student();
- Student s4 =new Student();
- Student s5 = s1;
- System.out.print("普通类对象的==非默认构造:");
- System.out.println(s1 == s2);
- System.out.println(s1 == s5);
- System.out.println("-----");
- System.out.print("普通类对象的equals非默认构造:");
- System.out.println(s1.equals(s2));
- System.out.println(s1.equals(s5));
- System.out.println("-----");
- System.out.print("普通类对象的==默认构造:");
- System.out.println(s3 == s4);
- System.out.println("-----");
- System.out.print("普通类对象的equals默认构造:");
- System.out.println(s3.equals(s4));
- System.out.println("-----");
- System.out.print("对普通对象的属性进行比较equals:");
- System.out.println(s1.name.equals(s2.name));
- System.out.print("对普通对象的属性进行比较==:");
- System.out.println(s1.name == s2.name);
- }
- }
- class Student{
- public String name;
- public int age;
- public Student(){
- }
- publicStudent(String name,int age){
- this.name = name;
- this.age = age;
- }
- public void test(){
- System.out.println(this.name);
- System.out.println(this.age);
- }
- }
- 普通类对象的==非默认构造:false
- true-----
- 普通类对象的equals非默认构造:false
- true-----
- 普通类对象的==默认构造:false-----
- 普通类对象的equals默认构造:false-----
- 对普通对象的属性进行比较equals:true
- 对普通对象的属性进行比较==:true
从以上的三个程序可以看出:
1)对于 ==:在简单类型中 (int 等),这能使用该方法进行比较,这种类型没有 equals 方法,int 的值是存在栈中的,== 比较的是栈的内容是否相同。在 String 类型中,比较特殊,用 String="";这种进行赋值时,两个相同的值用 == 比较也是相同的。但是用 new String(),赋值就不相同。说明 String=""时,java 会检查在堆中是否由相同的值,如果有,把新对象的地址也同老对象的地址赋为相同,因此 == 比较会相同。但是 new String() 开辟的就是两个栈,因此用 == 比较不会相同。对于包装类,如 Integer="";时,在 - 128-127 会有缓存,请看上面程序。其他的情况与 String 类似。
2) 对于 equals:当时 String 类型或者是包装类,如 Integer 时,比较的就是堆中的值,Integer 也无缓存之说。对于普通类,equals 比较的内存的首地址,这时候和 == 是一样的,即比较两边指向的是不是同一个对象。详细请见程序三。
来源: http://www.bubuko.com/infodetail-2142138.html