Java에서 ==와 equals ()의 차이점은 무엇입니까?

Java에서 ==와 equals ()의 차이점은 무엇입니까?

---

이 내용을 올바르게 이해하는지 명확히하고 싶었습니다.

• == -> 참조 비교입니다. 즉, 두 개체가 동일한 메모리 위치를 가리 킵니다.
• .equals() -> 객체의 값 비교를 평가합니다.

내 이해가 맞습니까?

---

일반적으로 귀하의 질문에 대한 대답은 "예"이지만 ...

• .equals(...) 비교하기 위해 작성된 내용 만 비교할 것입니다.
• 클래스가 equals 메서드를 재정의하지 않으면이 메서드를 재정 equals(Object o)의 한 가장 가까운 상위 클래스 의 메서드가 기본값으로 사용됩니다.
• 재정의를 제공 한 부모 클래스가 없으면 기본적으로 최종 부모 클래스 인 Object의 Object#equals(Object o)메서드 가 사용되므로 메서드 가 남습니다 . Object API에 따라 이것은 다음과 같습니다 ==. 즉, 두 변수가 동일한 객체를 참조하는 경우에만 해당 참조가 하나이고 동일한 경우 true를 반환합니다 . 따라서 기능적 동등성이 아닌 객체 동등성을 테스트 하게 됩니다.
• "계약을 위반"하지 않도록 재정의하는 hashCode경우 항상 재정의 하는 것을 기억하십시오 equals. API에 따라 hashCode()두 객체 의 메서드 에서 반환 된 결과는 두 객체 의 메서드 가 동일하다고 표시되는 경우 동일 해야합니다equals . 그 반대가 반드시 사실 은 아닙니다 .

---

String 클래스와 관련하여 :

equals () 메서드 는 두 객체 참조가 동일한 String 인스턴스를 참조하는지 여부에 관계없이 String 인스턴스 (힙) 내부의 "값"을 비교합니다. String 유형의 두 개체 참조가 동일한 String 인스턴스를 참조하면 훌륭합니다! 두 개체 참조가 두 개의 다른 String 인스턴스를 참조하는 경우 .. 차이가 없습니다. 비교되는 각 String 인스턴스 내의 "값"(즉, 문자 배열의 내용)입니다.

반면에 "==" 연산자 는 두 개체 참조 의 값을 비교 하여 동일한 String 인스턴스 를 참조하는지 확인합니다 . 두 개체의 값이 동일한 String 인스턴스를 "참조"하는 경우 부울 식의 결과는 "true".. duh가됩니다. 반면에 두 객체의 값이 서로 다른 String 인스턴스 를 "참조"하는 경우 (두 String 인스턴스에 동일한 "값"이 있더라도, 즉 각 String 인스턴스의 문자 배열 내용이 동일하더라도) 부울 표현식의 결과는 "false"입니다.

다른 설명과 마찬가지로 가라 앉히십시오.

나는 이것이 약간의 일을 정리하기를 바랍니다.

---

"프리미티브"또는 "객체 유형"에 대해 말하는지 여부에 따라 약간의 차이가 있습니다. "정적"또는 "비 정적"멤버에 대해 이야기하는 경우에도 마찬가지입니다. 위의 모든 것을 혼합 할 수도 있습니다 ...

다음은 예입니다 (실행 가능).

public final class MyEqualityTest
{
    public static void main( String args[] )
    {
        String s1 = new String( "Test" );
        String s2 = new String( "Test" );

        System.out.println( "\n1 - PRIMITIVES ");
        System.out.println( s1 == s2 ); // false
        System.out.println( s1.equals( s2 )); // true

        A a1 = new A();
        A a2 = new A();

        System.out.println( "\n2 - OBJECT TYPES / STATIC VARIABLE" );
        System.out.println( a1 == a2 ); // false
        System.out.println( a1.s == a2.s ); // true
        System.out.println( a1.s.equals( a2.s ) ); // true

        B b1 = new B();
        B b2 = new B();

        System.out.println( "\n3 - OBJECT TYPES / NON-STATIC VARIABLE" );
        System.out.println( b1 == b2 ); // false
        System.out.println( b1.getS() == b2.getS() ); // false
        System.out.println( b1.getS().equals( b2.getS() ) ); // true
    }
}

final class A
{
    // static
    public static String s;
    A()
    {
        this.s = new String( "aTest" );
    }
}

final class B
{
    private String s;
    B()
    {
        this.s = new String( "aTest" );
    }

    public String getS()
    {
        return s;
    }

}

다음 링크를 통해 "=="(동등 연산자) 및 ".equals (...)"(java.lang.Object 클래스의 메소드)에 대한 설명을 비교할 수 있습니다.

• == : http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html
• .equals (...) : http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)

---

==와 같음의 차이는 내가 자세히 살펴보기로 결정하기 전까지 언젠가 나를 혼란스럽게했습니다. 그들 중 대부분은 문자열을 비교하기 위해 사용한다라고 equals하지 ==. 이 답변에서 나는 차이점을 말할 수 있기를 바랍니다.

이 질문에 답하는 가장 좋은 방법은 자신에게 몇 가지 질문을하는 것입니다. 그럼 시작하겠습니다.

아래 프로그램의 출력은 무엇입니까?

String mango = "mango";
String mango2 = "mango";
System.out.println(mango != mango2);
System.out.println(mango == mango2);

당신이 말하는 경우,

false
true

나는 당신이 옳다고 말할 것이지만 왜 그렇게 말했 습니까? 출력이 다음과 같다고하면

true
false

네가 틀렸다고 말 하겠지만 그래도 물어볼 게 왜 그게 옳다고 생각하니?

좋아,이 질문에 답해 보자.

아래 프로그램의 출력은 무엇입니까?

String mango = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango3);
System.out.println(mango == mango3);

이제 당신이 말하면

false
true

나는 당신이 틀렸다고 말할 것이지만 지금은 왜 틀렸 습니까? 이 프로그램의 올바른 출력은 다음과 같습니다.

true
false

위의 프로그램을 비교하고 생각 해보세요.

확인. 이제 이것은 도움이 될 것입니다 (이것을 읽으십시오 : 개체의 주소를 인쇄하십시오 -불가능하지만 여전히 사용할 수 있습니다.)

String mango = "mango";
String mango2 = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango2);
System.out.println(mango == mango2);
System.out.println(mango3 != mango2);
System.out.println(mango3 == mango2);
// mango2 = "mang";
System.out.println(mango+" "+ mango2);
System.out.println(mango != mango2);
System.out.println(mango == mango2);

System.out.println(System.identityHashCode(mango));
System.out.println(System.identityHashCode(mango2));
System.out.println(System.identityHashCode(mango3));

위 코드에서 마지막 세 줄의 출력에 대해 생각할 수 있습니까? 나를 위해 ideone이 이것을 인쇄했습니다 ( 여기에서 코드를 확인할 수 있습니다 ).

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

오! 이제 identityHashCode (mango)가 identityHashCode (mango2)와 같지만 identityHashCode (mango3)와 같지 않습니다.

모든 문자열 변수 (mango, mango2 및 mango3)가 동일한 값 ( "mango") identityHashCode()을 갖더라도 여전히 모두에게 동일하지는 않습니다.

이제이 줄의 주석 처리를 제거 // mango2 = "mang";하고 이번에는 다시 실행하면 세 가지 identityHashCode()가 모두 다른 것을 볼 수 있습니다. 도움이되는 힌트입니다.

우리는 if hashcode(x)=N및 hashcode(y)=N=>x is equal to y

Java가 내부적으로 어떻게 작동하는지 잘 모르겠지만 이것이 내가 말했을 때 일어난 일이라고 가정합니다.

mango = "mango";

자바 "mango"는 mango다음과 같은 변수가 가리키는 문자열 을 만들었습니다.

mango ----> "mango"

이제 내가 말한 다음 줄에서 :

mango2 = "mango";

실제로 다음과 같은 동일한 문자열 "mango"을 재사용 했습니다.

mango ----> "mango" <---- mango2

mango와 mango2는 모두 같은 참조를 가리키고 있습니다.

mango3 = new String("mango")

실제로 "망고"에 대한 완전히 새로운 참조 (문자열)를 만들었습니다. 이렇게 생겼습니다.

mango -----> "mango" <------ mango2

mango3 ------> "mango"

내가 값을 넣어 이유의 것을 mango == mango2, 그것은 넣어 true. 에 대한 값을 mango3 == mango2입력 false하면 값이 동일하더라도 출력됩니다.

그리고 선의 주석을 해제했을 때 // mango2 = "mang";실제로 다음과 같이 그래프를 바꾸는 문자열 "mang"를 생성했습니다.

mango ---->"mango"
mango2 ----> "mang"
mango3 -----> "mango"

이것이 identityHashCode가 모든 사람에게 동일하지 않은 이유입니다.

이것이 당신에게 도움이되기를 바랍니다. 실제로 == 실패하고 equals () 통과하는 테스트 케이스를 생성하고 싶었습니다. 자유롭게 의견을 말하고 내가 틀렸다면 알려주십시오.

---

==의 두 변수 여부 운영자가 테스트는 (메모리 어드레스 포인터 일명) 동일한 참조 .

String foo = new String("abc");
String bar = new String("abc");

if(foo==bar)
// False (The objects are not the same)

bar = foo;

if(foo==bar)
// True (Now the objects are the same)

반면 등호 () 메소드 테스트 두 변수가있는 개체 참조 여부 동일한 상태 (값) .

String foo = new String("abc");
String bar = new String("abc");

if(foo.equals(bar))
// True (The objects are identical but not same)

건배 :-)

---

이 함수를 사용자 정의 클래스와 함께 사용하려면 equals 함수를 다른 것과 함께 재정의해야합니다.

equals 메소드는 객체를 비교합니다.

==이진 연산자는 메모리 어드레스를 비교한다.

---

== 및 .equals ()는 .equals ()를 재정의하지 않으면 동일한 객체를 참조합니다.

.equals ()를 재정의하면 원하는 것을 원합니다. 호출하는 객체의 상태를 전달 된 객체의 상태와 비교하거나 super.equals ()를 호출 할 수 있습니다.

---

.equals(...)비교하려는 클래스에 의해 구현되어야 함을 기억하십시오 . 그렇지 않으면 요점이 많지 않습니다. Object 클래스의 메서드 버전은 비교 작업과 동일한 작업을 수행합니다. Object # equals .

객체에 대해 비교 연산자를 실제로 사용하려는 유일한 시간은 Enum을 비교하는 것입니다. 한 번에 하나의 Enum 값 인스턴스 만 있기 때문입니다. 예를 들어 열거 형이 주어지면

enum FooEnum {A, B, C}

둘 이상의 인스턴스가 결코 A한 번에, 그리고에 같은 B과 C. 이것은 실제로 다음과 같은 메소드를 작성할 수 있음을 의미합니다.

public boolean compareFoos(FooEnum x, FooEnum y)
{
    return (x == y);
}

그리고 당신은 전혀 문제가 없을 것입니다.

---

 String w1 ="Sarat";
 String w2 ="Sarat";
 String w3 = new String("Sarat");

 System.out.println(w1.hashCode());   //3254818
 System.out.println(w2.hashCode());   //3254818
 System.out.println(w3.hashCode());   //3254818

 System.out.println(System.identityHashCode(w1)); //prints 705927765
 System.out.println(System.identityHashCode(w2)); //prints 705927765
 System.out.println(System.identityHashCode(w3)); //prints 366712642


 if(w1==w2)   //  (705927765==705927765)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true

 if(w2==w3)   //  (705927765==366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints false


 if(w2.equals(w3))   //  (Content of 705927765== Content of 366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true

---

==인 오퍼레이터 와 equals()A는 방법 .

연산자는 일반적으로 원시 유형 비교 ==에 사용 되므로 메모리 주소 비교 equals()에 사용되며 객체 비교에 방법이 사용 됩니다 .

---

== 연산자 :

==는 두 피연산자를 비교하는 데 사용되는 Java의 관계 연산자입니다. 두 피연산자가 같은지 여부를 결정하는 데 사용됩니다. == 연산자를 사용하면 int, char, float 및 Booleans와 같은 모든 기본 유형을 비교할 수 있습니다. 비교 후 == 연산자는 부울 값을 반환합니다. 두 피연산자가 같으면 == 연산자는 참 값을 반환합니다. 그러나 두 피연산자가 같지 않으면 false 값을 반환합니다. 개체와 함께 사용되는 경우 == 연산자는 두 개체 참조를 비교하고 동일한 인스턴스를 참조하는지 여부를 확인합니다.

.equals () 메서드

equals ()는 두 문자열을 비교하고 동일한 지 여부를 확인하는 데 사용되는 String 클래스에서 사용할 수있는 메서드입니다. 이 메서드는 비교 결과로 부울 값을 반환합니다. 두 문자열에 동일한 순서로 동일한 문자가 포함되어 있으면 equals () 메서드는 true를 반환합니다. 그렇지 않으면 거짓 값을 반환합니다.

---

또한 두 개체가 동일한 지 테스트하려는 경우 테스트하려는 첫 번째 항목 이므로 .equals()일반적으로 ==테스트 용 으로 포함 됩니다.

그리고 ==실제로는 참조를 확인하는 객체에 대한 기본 유형의 값을 확인합니다.

---

코드를 평가할 때 (==)는 메모리 주소에 따라 비교하고 equals (Object o)는 인스턴스의 hashCode ()를 비교한다는 것이 매우 분명합니다. 그렇기 때문에 나중에 놀라지 않을 경우 equals ()와 hashCode () 사이의 계약을 깨지 마십시오.

    String s1 = new String("Ali");
    String s2 = new String("Veli");
    String s3 = new String("Ali");

    System.out.println(s1.hashCode());
    System.out.println(s2.hashCode());
    System.out.println(s3.hashCode());


    System.out.println("(s1==s2):" + (s1 == s2));
    System.out.println("(s1==s3):" + (s1 == s3));


    System.out.println("s1.equals(s2):" + (s1.equals(s2)));
    System.out.println("s1.equal(s3):" + (s1.equals(s3)));


    /*Output 
    96670     
    3615852
    96670
    (s1==s2):false
    (s1==s3):false
    s1.equals(s2):false
    s1.equal(s3):true
    */

---

==와 equals ()의 주요 차이점은 다음과 같습니다.

1) ==는 프리미티브를 비교하는 데 사용됩니다.

예 :

        String string1 = "Ravi";
        String string2 = "Ravi";
        String string3 = new String("Ravi");
        String string4 = new String("Prakash");

        System.out.println(string1 == string2); // true because same reference in string pool
        System.out.println(string1 == string3); // false

2) equals ()는 객체를 비교하는 데 사용됩니다. 예 :

        System.out.println(string1.equals(string2)); // true equals() comparison of values in the objects
        System.out.println(string1.equals(string3)); // true
        System.out.println(string1.equals(string4)); // false

---

다음은 relational operator ==과 의 차이점에 대한 일반적인 규칙입니다 the method .equals().

object1 == object2object1 및 object2에서 참조하는 개체 가 Heap의 동일한 메모리 위치를 참조하는지 비교합니다 .

object1.equals(object2)object1과 object2의 값은 메모리 위치에 관계없이 비교 합니다 .

이것은 String을 사용하여 잘 보여줄 수 있습니다.

시나리오 1

 public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = new String("Hello");
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

 }



The result is
      is str1 == str2 ? false
      is str1.equals(str2) ? true 

시나리오 2

public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = "Hello";
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

}

The result is 
  is str1 == str2 ? true
  is str1.equals(str2) ? true

이 문자열 비교는 다른 유형의 개체를 비교하는 기준으로 사용할 수 있습니다.

예를 들어 Person 클래스 가 있는 경우 두 사람을 비교할 기준 기반 을 정의해야합니다 . 이 사람 클래스 에 키와 몸무게의 인스턴스 변수 가 있다고 가정 해 보겠습니다 .

따라서 사람 개체 person1 and person2를 만들고이 두 개체 를 비교 하려면 사람 클래스.equals() 의 equals 메서드 를 재정 의하여 비교가 될 인스턴스 변수 (heigh 또는 weight)를 기반으로 정의해야합니다.

그러나 == operator will still return results based on the memory location of the two objects(person1 and person2).

이 사람 객체 비교를 쉽게 일반화하기 위해 다음 테스트 클래스를 만들었습니다. 이러한 개념을 실험 해 보면 수많은 사실이 드러날 것 입니다.

package com.tadtab.CS5044;

public class Person {

private double height;
private double weight;

public double getHeight() {
    return height;
}

public void setHeight(double height) {
    this.height = height;
}

public double getWeight() {
    return weight;
}

public void setWeight(double weight) {
    this.weight = weight;
}


@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    long temp;
    temp = Double.doubleToLongBits(height);
    result = prime * result + (int) (temp ^ (temp >>> 32));
    return result;
}

@Override
/**
 * This method uses the height as a means of comparing person objects.
 * NOTE: weight is not part of the comparison criteria
 */
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Person other = (Person) obj;
    if (Double.doubleToLongBits(height) != Double.doubleToLongBits(other.height))
        return false;
    return true;
}

public static void main(String[] args) {

    Person person1 = new Person();
    person1.setHeight(5.50);
    person1.setWeight(140.00);

    Person person2 = new Person();
    person2.setHeight(5.70);
    person2.setWeight(160.00);

    Person person3 = new Person();
    person3 = person2;

    Person person4 = new Person();
    person4.setHeight(5.70);

    Person person5 = new Person();
    person5.setWeight(160.00);

    System.out.println("is person1 == person2 ? " + (person1 == person2)); // false;
    System.out.println("is person2 == person3 ? " + (person2 == person3)); // true 
    //this is because perosn3 and person to refer to the one person object in memory. They are aliases;
    System.out.println("is person2.equals(person3) ? " + (person2.equals(person3))); // true;

    System.out.println("is person2.equals(person4) ? " + (person2.equals(person4))); // true;

    // even if the person2 and person5 have the same weight, they are not equal.
    // it is because their height is different
    System.out.println("is person2.equals(person4) ? " + (person2.equals(person5))); // false;
}

}

이 클래스 실행의 결과는 다음과 같습니다.

is person1 == person2 ? false
is person2 == person3 ? true
is person2.equals(person3) ? true
is person2.equals(person4) ? true
is person2.equals(person4) ? false

---

==많은 객체 유형에서 사용할 수 있지만 Object.equals모든 유형, 특히 문자열 및 Google지도 마커에 사용할 수 있습니다 .

---

== 연산자는 항상 참조를 비교합니다. 그러나

equals () 메서드

재정의 된 메서드에서 주어진 구현의 기본에 대해 객체를 비교하는 것보다 재정의 된 경우 구현에 따라 다릅니다.

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//fasle
      obj==obj1 // fasle
    }
 }

위의 코드에서 obj와 obj1 객체는 동일한 데이터를 포함하지만 참조가 동일하지 않으므로 false 및 ==도 반환합니다. 그러나 우리가 다음과 같은 메소드를 재정의하면

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }
    public boolean equals(Object obj)
    {
       A a1=(A)obj;
      return this.id==a1.id;
    }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//true
      obj==obj1 // fasle
    }
 }

우리가 재정의 한 경우에만 true와 false를 반환합니다.

method와 같습니다.

객체의 내용 (id)에 대한 기본 객체를 비교합니다.

하지만 ==

여전히 객체의 참조를 비교합니다.

---

public class StringPool {

public static void main(String[] args) {

    String s1 = "Cat";// will create reference in string pool of heap memory
    String s2 = "Cat";
    String s3 = new String("Cat");//will create a object in heap memory

    // Using == will give us true because same reference in string pool

    if (s1 == s2) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using == with reference and Object will give us False

    if (s1 == s3) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using .equals method which refers to value

    if (s1.equals(s3)) {
        System.out.println("true");
    } else {
        System.out.println("False");
    }

    }
  }

---- 출력 ----- 참 거짓 참

---

기본 유형에 대한 래퍼 객체에 대해 추가 할 가치가 있습니다. 즉, Int, Long, Double-== 두 값이 같으면 true를 반환합니다.

Long a = 10L;
Long b = 10L;

if (a == b) {
    System.out.println("Wrapped primitives behave like values");
}

대조적으로 위의 두 Long을 두 개의 개별 ArrayList에 넣으면 equals는 동일한 것으로 보지만 ==는 그렇지 않습니다.

ArrayList<Long> c = new ArrayList<>();
ArrayList<Long> d = new ArrayList<>();

c.add(a);
d.add(b);
if (c == d) System.out.println("No way!");
if (c.equals(d)) System.out.println("Yes, this is true.");

---

문자열 풀 (일명 인턴 ) 및 정수 풀 흐림 더의 차이는, 당신은 사용할 수 있습니다 ==경우에 따라 개체를 대신.equals

이렇게하면 복잡성이 증가하는 대신 성능 (?)이 향상 될 수 있습니다.

예 :

assert "ab" == "a" + "b";

Integer i = 1;
Integer j = i;
assert i == j;

복잡성 절충 : 다음 사항이 놀라 울 수 있습니다.

assert new String("a") != new String("a");

Integer i = 128;
Integer j = 128;
assert i != j;

이러한 미세 최적화를 피하고 항상.equals 객체와 ==기본 요소에 사용 하는 것이 좋습니다 .

assert (new String("a")).equals(new String("a"));

Integer i = 128;
Integer j = 128;
assert i.equals(j);

---

기본적으로 ==두 개체가 힙에서 동일한 참조를 가지고 있는지 비교하므로 두 참조가 동일한 개체에 연결되지 않는 한이 비교는 거짓이됩니다.

equals()Object클래스 에서 상속 된 메서드 입니다. 이 방법은 기본적으로 두 개체의 참조가 동일한 지 비교합니다. 그 뜻은:

object1.equals(object2) <=> object1 == object2

그러나 동일한 클래스의 두 개체간에 동일성을 설정하려면이 메서드를 재정의해야합니다. 재정의 한 hashCode()경우 메서드를 재정의하는 것도 매우 중요합니다 equals().

hashCode()동등성을 설정할 때 구현 이 Java Object Contract의 일부입니다. 컬렉션으로 작업 hashCode()중이고 구현하지 않은 경우 이상한 나쁜 일이 발생할 수 있습니다.

HashMap<Cat, String> cats = new HashMap<>();
Cat cat = new Cat("molly");
cats.put(cat, "This is a cool cat");
System.out.println(cats.get(new Cat("molly"));

null구현하지 않은 경우 이전 코드를 실행 한 후 인쇄됩니다 hashCode().

---

Java는 연산자 오버로딩을 지원하지 않기 때문에 ==는 모든 객체에 대해 동일하게 동작하지만 equals ()는 메소드로 Java에서 재정의 할 수 있으며 객체를 비교하는 논리는 비즈니스 규칙에 따라 변경 될 수 있습니다.

Java에서 ==와 equals의 주요 차이점은 "=="는 기본 요소를 비교하는 데 사용되는 반면 equals () 메서드는 객체의 동등성을 확인하는 데 권장된다는 것입니다.

문자열 비교는 == 및 equals 메서드를 모두 사용하는 일반적인 시나리오입니다. java.lang.String 클래스 오버라이드는 메소드와 같으므로 두 개의 String 객체가 동일한 내용을 포함하면 true를 반환하지만 ==는 두 개의 참조가 동일한 객체를 가리키는 경우에만 true를 반환합니다.

다음은 == 및 equals () 메소드를 사용하여 Java에서 두 문자열을 비교 하는 예 입니다.

public class TEstT{

    public static void main(String[] args) {

String text1 = new String("apple");
String text2 = new String("apple");

//since two strings are different object result should be false
boolean result = text1 == text2;
System.out.println("Comparing two strings with == operator: " + result);

//since strings contains same content , equals() should return true
result = text1.equals(text2);
System.out.println("Comparing two Strings with same content using equals method: " + result);

text2 = text1;
//since both text2 and text1d reference variable are pointing to same object
//"==" should return true
result = (text1 == text2);
System.out.println("Comparing two reference pointing to same String with == operator: " + result);

}
}

---

간단히 말해서 대답은 "예"입니다.

Java에서 ==연산자는 두 객체를 비교하여 동일한 메모리 위치를 가리키는 지 확인합니다. 그동안 .equals()에있어서 실제로 두 객체를 비교가 동일한 개체 값이 있는지.

참고 URL : https://stackoverflow.com/questions/7520432/what-is-the-difference-between-and-equals-in-java