Java에서 객체가 동일한지 판단하는 equals() 방법에 대한 자습서 사용

Object 클래스의 equals 메서드는 한 객체가 다른 객체와 동일한지 확인하는 데 사용됩니다.Object 클래스에서 이 방법은 두 대상이 같은 인용을 가지고 있는지 판단한다. 만약 두 대상이 같은 인용을 가지고 있다면 그들은 반드시 같다.이 점에서 기본 조작으로 삼는 것도 이치에 맞다.그러나 다수의 유형에 대해 이런 판단은 아무런 의미가 없다. 예를 들어 이런 방식으로 두 Print Stream이 같은지 아닌지를 비교하면 전혀 의미가 없다.그러나 두 대상의 상태의 상등성을 자주 검사해야 한다. 만약 두 대상의 상태가 같다면 이 두 대상은 상등하다고 여긴다.그래서 보통 사용자 정의 클래스에서 equals 비교를 다시 써야 합니다.
다음은 완벽한 equals () 방법을 작성하는 방법에 대한 조언입니다.
(1) 현식 매개 변수는otherObject로 명명되었습니다. 이따가other라는 변수로 변환해야 합니다
(2) this가 otherObject와 같은 객체를 참조하는지 확인합니다.

if(this==otherObject) return true;

이 문장은 단지 최적화일 뿐이다.실제로 이것은 자주 채택하는 형식이다.이 등식을 계산하는 것은 분류 중의 영역을 하나하나 비교하는 것보다 대가가 적기 때문이다.
(3) otherObject가null인지 검사하고null이면false로 돌아갑니다.이 검사는 매우 필요한 것이다.

if(otherObject==null) return false;

(4)this와otherObject가 같은 클래스에 속하는지 비교하고, equals의 의미가 모든 하위 클래스에서 바뀌면 getClass () 검사를 사용하여 자신을 목표 클래스로 삼는다

if(getClass()!=otherObject.getClass()) return false;

만약 모든 하위 클래스가 같은 의미를 가지고 있다면, instanceof 검사를 사용합니다

if(!(otherObject instanceof ClassName)) return false;

(5) otherObject를 해당 유형의 변수로 변환합니다.

ClassName other=(ClassName)otherObject;

(6) 이제 비교가 필요한 모든 도메인을 비교합니다.사용 = = = 기본 형식 필드를 비교하고, equals를 사용하여 대상 필드를 비교합니다.모든 필드가 일치하면true로 돌아가고false로 돌아갑니다.

return field1==other.field1&&field2.equals(other.field2)

하위 클래스에서 equals를 다시 정의하면 호출된 슈퍼를 포함해야 합니다.equals(other).만약 검측에 실패한다면 동일할 수 없다.초클래스의 필드가 같으면 하위 클래스의 실례 필드를 비교합니다.
그룹 형식의 영역에 대해 정적 Arrays를 사용할 수 있습니다.equals 방법은 상응하는 원소가 같은지 검사한다.
몇 가지 문자열 비교 예를 살펴보겠습니다.

String a = "abc"; 
String b = "abc"; 
String c = new String("abc"); 
String d = new String("abc"); 
System.out.println(a == b); // true  JAVA ，  
System.out.println(a == c); // false a c 2  
System.out.println(a.equals(c)); // true  String equals ， true。( Object equals ) 
System.out.println(c==d); // false c d ， 2 ，  
System.out.println(c.equals(d)); // true 

간단하게 말하면 문자열의 상수를 비교할 때 equals가 되돌아온 결과와 같고, 문자열 대상의 값을 비교하고 싶을 때 equals를 사용한다.
equals의 사용 예를 보십시오.

package chapter05.EqualsTest; 
 
import java.util.*; 
 
public class EqualsTest { 
 public static void main(String[] args) { 
  Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15); 
  Employee alice2 = alice1; // reference the same object 
  Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15); 
  Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1); 
 
  System.out.println("alice1 == alice2: " + (alice1 == alice2)); 
 
  System.out.println("alice1 == alice3: " + (alice1 == alice3)); 
 
  System.out.println("alice1.equals(alice3): " + (alice1.equals(alice3))); 
 
  System.out.println("alice1.equals(bob): " + (alice1.equals(bob))); 
 
  System.out.println(bob.toString()); 
 } 
} 
 
class Employee { 
 public Employee(String n, double s, int year, int month, int day) { 
  name = n; 
  salary = s; 
  GregorianCalendar calendar = new GregorianCalendar(year, month, day); 
  hireDay = calendar.getTime(); 
 } 
 
 public String getName() { 
  return name; 
 } 
 
 public double getSalary() { 
  return salary; 
 } 
 
 public Date getHireDay() { 
  return hireDay; 
 } 
 
 public void raiseSalary(double byPercent) { 
  double raise = salary * byPercent / 100; 
  salary += raise; 
 } 
 
 @Override 
 public boolean equals(Object otherObject) { 
  // a quick test to see if the objects are identical 
  if (this == otherObject) 
   return true; 
 
  // must return false if the explicit parameter is null 
  if (otherObject == null) 
   return false; 
 
  // if the classed don't match,they can't be equal 
  if (getClass() != otherObject.getClass()) 
   return false; 
 
  // now we know otherObject is a non-null Employee 
  Employee other = (Employee) otherObject; 
 
  // test whether the fields hava identical values 
  return name.equals(other.name) && salary == other.salary 
    && hireDay.equals(other.hireDay); 
 
 } 
 
 @Override 
 public int hashCode() { 
  return 7 * name.hashCode() + 11 * new Double(salary).hashCode() + 13 
    * hireDay.hashCode(); 
 } 
 
 @Override 
 public String toString() { 
  return getClass().getName() + "[name=" + name + ",salary=" + salary 
    + ",hireDay=" + hireDay + "]"; 
 } 
 
 private String name; 
 private double salary; 
 private Date hireDay; 
} 
 
class Manager extends Employee { 
 public Manager(String n, double s, int year, int month, int day) { 
  super(n, s, year, month, day); 
  bouns = 0; 
 } 
 
 @Override 
 public double getSalary() { 
  double baseSalary = super.getSalary(); 
  return baseSalary + bouns; 
 } 
 
 public void setBouns(double b) { 
  bouns = b; 
 } 
 
 @Override 
 public boolean equals(Object otherObject) { 
  if (!super.equals(otherObject)) 
   return false; 
  Manager other = (Manager) otherObject; 
  // super equals checked that this and other belong to the same class 
  return bouns == other.bouns; 
 } 
 
 @Override 
 public int hashCode() { 
  return super.hashCode() + 17 * new Double(bouns).hashCode(); 
 } 
 
 @Override 
 public String toString() { 
  return super.toString() + "[bouns=" + bouns + "]"; 
 } 
 
 private double bouns; 
} 

깊이 들어가다
다음은'클래스가 equals () 방법을 덮어쓰는지 여부'에 따라 두 종류로 나뉩니다.
(1) 만약 어떤 종류가 equals () 방법을 덮어쓰지 않는다면, equals () 를 통해 두 대상을 비교할 때, 실제로는 두 대상이 같은 대상인지 비교한다."=="를 통해 두 객체를 비교하는 것과 같습니다.
(2) 우리는 클래스의 equals () 방법을 덮어써서 equals () 가 다른 방식으로 두 대상이 같은지 비교할 수 있다.일반적인 방법은 두 대상의 내용이 같으면 equals () 방법이true로 되돌아오는 것이다.그렇지 않으면fasle로 돌아갑니다.
다음은 위의 두 가지 상황을 예로 들어 설명한다.
1. "equals() 메서드를 덮어쓰지 않음"
코드는 다음과 같습니다(EqualsTest1.java).

import java.util.*;
import java.lang.Comparable;

/**
 * @desc equals() 。

 */
public class EqualsTest1{

 public static void main(String[] args) {
  //  2 Person ，
  //  equals 
  Person p1 = new Person("eee", 100);
  Person p2 = new Person("eee", 100);
  System.out.printf("%s
", p1.equals(p2));
 }

 /**
  * @desc Person 。
  */
 private static class Person {
  int age;
  String name;

  public Person(String name, int age) {
   this.name = name;
   this.age = age;
  }

  public String toString() {
   return name + " - " +age;
  }
 }
}

실행 결과:

false

결과 분석
우리는 p1을 통해equals(p2)에서 "p1과 p2가 같은지 비교할 때"실제로 호출된 Object.java의 equals () 방법, 즉 호출된 (p1==p2).이것은 "p1과 p2가 같은 대상인지 아닌지를 비교합니다."
p1과 p2의 정의에서 알 수 있듯이 내용은 같지만하지만 그들은 두 개의 다른 대상이다!따라서 반환 결과는false입니다.
2. "equals() 메서드 덮어쓰기"의 경우
위의 Equals Test1을 수정합니다.java: equals () 덮어쓰기 방법.
코드는 다음과 같습니다(EqualsTest2.java).

import java.util.*;
import java.lang.Comparable;

/**
 * @desc equals() 。
 */
public class EqualsTest2{

 public static void main(String[] args) {
  //  2 Person ，
  //  equals 
  Person p1 = new Person("eee", 100);
  Person p2 = new Person("eee", 100);
  System.out.printf("%s
", p1.equals(p2));
 }

 /**
  * @desc Person 。
  */
 private static class Person {
  int age;
  String name;

  public Person(String name, int age) {
   this.name = name;
   this.age = age;
  }

  public String toString() {
   return name + " - " +age;
  }

  /** 
   * @desc  equals  
   */ 
  @Override
  public boolean equals(Object obj){ 
   if(obj == null){ 
    return false; 
   } 

   // true， false 
   if(this == obj){ 
    return true; 
   } 

   //  
   if(this.getClass() != obj.getClass()){ 
    return false; 
   } 

   Person person = (Person)obj; 
   return name.equals(person.name) && age==person.age; 
  } 
 }
}

실행 결과:

true

결과 분석:
Equals Test2에 있습니다.java에서 Person의 equals () 함수를 다시 썼습니다. 두 Person 대상의name과age가 같으면true를 되돌려줍니다.
따라서 실행 결과는true로 돌아갑니다.
여기까지 말씀드리는 김에 자바가 equals () 에 대한 요구를 말씀드리겠습니다.다음과 같은 몇 가지가 있습니다.
대칭성: x.equals(y)가 "true"로 되돌아오면 y.equals(x)도 "true"로 되돌아가야 합니다.
반사성: x.equals(x)는 "true"로 되돌아가야 합니다.
유추성: x.equals(y)가 "true"로 되돌아오고 y.equals(z)가 "true"로 되돌아오면 z.equals(x)도 "true"로 되돌아와야 합니다.
일치성: 만약 x.equals(y)가 "true"로 되돌아온다면, x와 y의 내용이 계속 변하지 않는다면, x.equals(y)를 몇 번 반복하든지 간에 되돌아오는 것은 "true"이다.
비공성, x.equals(null), 영원히 "false"로 되돌아옵니다.x.equals (x와 다른 유형의 대상) 는 영원히 "false"로 되돌아옵니다.
이제 equals()의 작용을 다시 한 번 돌이켜보면 두 대상이 같은지 아닌지를 판단한다.우리가 equals () 를 다시 쓸 때, 절대로 그것의 작용을 바꾸지 못할 것이다.
equals()와 ==의 차이점은 무엇입니까?
=: 두 객체의 주소가 동일한지 여부를 판단하는 역할을 합니다.두 대상이 같은 대상인지 아닌지를 판단하는 것이다.
equals (): 두 대상이 같은지 아닌지를 판단하는 역할도 합니다.그러나 일반적으로 두 가지 사용법이 있습니다(앞의 첫 번째 부분에서 자세히 설명했습니다).
상황 1, 클래스는 equals () 를 덮어쓰는 방법이 없습니다.이 클래스의 두 객체를 equals () 를 통해 비교할 때 "=="를 통해 비교하는 것과 같습니다.
상황 2, 클래스는 equals () 방법을 덮어씁니다.일반적으로 우리는 equals() 방법을 덮어쓰고 두 대상의 내용이 같다.만약 그것들의 내용이 같다면true를 되돌려줍니다. 즉, 이 두 대상이 같다고 생각됩니다.
다음은 예시를 통해 그것들의 차이를 비교한다.
코드는 다음과 같습니다.

import java.util.*;
import java.lang.Comparable;

/**
 * @desc equals() 。
 */
public class EqualsTest3{

 public static void main(String[] args) {
  //  2 Person ，
  //  equals 
  Person p1 = new Person("eee", 100);
  Person p2 = new Person("eee", 100);
  System.out.printf("p1.equals(p2) : %s
", p1.equals(p2));
  System.out.printf("p1==p2 : %s
", p1==p2);
 }

 /**
  * @desc Person 。
  */
 private static class Person {
  int age;
  String name;

  public Person(String name, int age) {
   this.name = name;
   this.age = age;
  }

  public String toString() {
   return name + " - " +age;
  }

  /** 
   * @desc  equals  
   */ 
  @Override
  public boolean equals(Object obj){ 
   if(obj == null){ 
    return false; 
   } 

   // true， false 
   if(this == obj){ 
    return true; 
   } 

   //  
   if(this.getClass() != obj.getClass()){ 
    return false; 
   } 

   Person person = (Person)obj; 
   return name.equals(person.name) && age==person.age; 
  } 
 }
}

실행 결과:

p1.equals(p2) : true
p1==p2 : false

결과 분석:
Equals Test 3.java:
(1) p1.equals(p2)
이것은 p1과 p2의 내용이 같은지 아닌지를 판단하는 것이다.Person이 equals() 방법을 덮어쓰기 때문에 이 equals()는 p1과 p2의 내용이 같은지 아닌지를 판단하는 데 사용되며, 마침 p1과 p2의 내용이 같다.따라서true로 돌아갑니다.
(2) p1==p2
이것은 p1과 p2가 같은 대상인지 아닌지를 판단하는 것이다.각각 새로 만든 두 Person 객체이기 때문에따라서false로 돌아갑니다.