Java에서 ==와 equals()의 차이점은 무엇입니까?
제가 제대로 이해하고 있는지 명확히 하고 싶습니다.
==두 가 같은 있습니다..equals()값 로 평가합니다.
일반적으로, 당신의 질문에 대한 대답은 "예"입니다만...
.equals(...)그 이상도 그 이하도 아닌, 단지 비교하기 위해 쓰여진 것을 비교할 뿐입니다.- 메서드를 ="가 .
equals(Object o)이 메서드를 재정의한 가장 가까운 부모 클래스의 메서드. - Object로 기본 "Object"는 "Object"로 .★★★★★★★★★★★★★★★★,
Object#equals(Object o)이는 API와 동일합니다.==즉, 두 변수가 모두 동일한 개체를 참조하는 경우에만 true를 반환합니다.따라서 기능적 평등이 아닌 객체의 평등을 테스트하게 됩니다. - ""를 덮어쓰는 .
hashCode「」를equals위반을 방지하기 '따라 API에서 된 결과입니다.hashCode()두 객체의 메서드는 동일해야 합니다.equals두 방법이 동등하다는 것을 나타냅니다.그 반대가 반드시 맞는 것은 아니다.
String 클래스에 대해서:
equals() 메서드는 두 객체 참조가 동일한 String 인스턴스를 참조하는지 여부에 관계없이 String 인스턴스 내의 값(히프)을 비교합니다.String 유형의 두 개체 참조가 동일한 String 인스턴스를 참조하면 매우 좋습니다.2개의 오브젝트 참조가 2개의 다른 String 인스턴스를 참조하는 경우.그렇다고 달라질 건 없어비교되는 각 String 인스턴스 내의 "값"(즉, 문자 배열의 내용)입니다.
한편, "==" 연산자는 두 개체 참조의 값을 비교하여 동일한 String 인스턴스를 참조하는지 확인합니다.두 개체 참조 값이 동일한 String 인스턴스를 "참조"하는 경우 부울식의 결과는 "참"이 됩니다.duh. 반면 두 객체의 값이 서로 다른 String 인스턴스를 참조하는 경우(두 String 인스턴스의 값이 동일한 경우, 즉 각 String 인스턴스의 문자 배열 내용이 동일함) 부울식의 결과는 "false"가 됩니다.
다른 설명과 마찬가지로, 그것을 이해하도록 하세요.
이것으로 일이 좀 해결되었으면 좋겠다.
"primitive" 또는 "Object Types" 중 어느 쪽을 말하는지에 따라 약간의 차이가 있습니다. "static" 또는 "non-static" 멤버를 말하는 경우에도 마찬가지입니다.또, 위의 모든 것을 혼재시킬 수도 있습니다.
다음으로 (실행할 수 있는) 예를 나타냅니다.
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;
}
}
"=="(Equality 연산자)와 ".equality"(...)의 설명을 비교할 수 있습니다.오브젝트 클래스)는 다음 링크를 경유합니다.
- ==: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html
- .filename(...):http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)
==와 동등한 것의 차이 때문에 잠시 혼란스러웠지만 자세히 알아보기로 했습니다.는 '비교'를 해야 한다고 가 많습니다.equals and==이 답변에서 차이를 말할 수 있기를 바랍니다.
이 질문에 대답하는 가장 좋은 방법은 스스로에게 몇 가지 질문을 하는 것입니다.그럼 시작합시다.
아래 프로그램의 출력은 무엇입니까?
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));
위의 코드에 있는 마지막 세 줄의 출력에 대해 생각해 보세요.이것을 인쇄한 사람이 있습니다(여기서 코드를 확인하실 수 있습니다).
false
true
true
false
mango mango
false
true
17225372
17225372
5433634
오! 이제 정체가 보이는군HashCode(mango)는 ID와 동일합니다.HashCode(mango2) 단, ID와 동일하지 않습니다.해시 코드(mango3)
비록 모든 문자열 변수인 망고, 망고2, 망고3가 같은 값, 즉 망고를 가지고 있지만,identityHashCode()모든 사람에게 똑같지는 않다.
이 행의 해 보겠습니다.// mango2 = "mang";한 번 세 가지 다 거예요.identityHashCode()이 되다. 음, 도움이 힌트네요.
우리는 알고 있다hashcode(x)=N ★★★★★★★★★★★★★★★★★」hashcode(y)=N> =>x is equal to y
java가 내부적으로 어떻게 동작하는지는 모르겠지만, 제가 이렇게 말했을 때 이렇게 된 것 같습니다.
mango = "mango";
java를 ."mango"mango와 같은 것
mango ----> "mango"
다음 줄에 제가 말씀드렸듯이
mango2 = "mango";
했습니다."mango"
mango ----> "mango" <---- mango2
망고와 망고2가 같은 참조를 가리키고 있습니다. 제가 말씀드린 바로는
mango3 = new String("mango")
mango에 대한 완전히 새로운 참조(문자열)가 생성되었습니다.이렇게 생겼는데
mango -----> "mango" <------ mango2
mango3 ------> "mango"
가 래 for의 을 했을 때mango == mango2 , , , , 을.true, 「 」의 값을 mango3 == mango2 , , , , 을.false（ ( ( ( ( ( ( ( ( ( ( 。
, 했을 때.// mango2 = "mang";실제로 "mang" 문자열이 생성되어 그래프가 다음과 같이 변환되었습니다.
mango ---->"mango"
mango2 ----> "mang"
mango3 -----> "mango"
이게 바로 아이덴티티가해시 코드는 모든 것에 동일하지 않습니다.
도움이 되시길 바랍니다.사실 저는 ==가 실패하고 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)
한편 equals() 메서드는 두 변수가 동일한 상태(값)를 가진 개체를 참조하는지 여부를 테스트합니다.
String foo = new String("abc");
String bar = new String("abc");
if(foo.equals(bar))
// True (The objects are identical but not same)
건배 :-)
커스텀 클래스에서 사용하려면 (다른 함수와 함께) equals 함수를 재정의해야 합니다.
equal 메서드는 오브젝트를 비교합니다.
==이진 연산자는 메모리 주소를 비교합니다.
==연산자이고equals()메서드입니다.
연산자는 일반적으로 원시 유형 비교에 사용되므로== 주소 및 메모리 주소 비교에 됩니다.equals()method는 객체를 비교하기 위해 사용됩니다.
==와 .disc() 모두 .disccs를 재정의하지 않으면 동일한 개체를 참조합니다.
.equals()를 덮어쓰면 무엇을 할 것인가.호출 객체의 상태를 전달 객체의 상태와 비교하거나 super.equals()를 호출할 수 있습니다.
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(...)비교하려는 클래스에 의해 구현되어야 합니다.그렇지 않으면 포인트가 별로 없습니다.오브젝트 클래스의 메서드 버전은 비교 조작과 같은 작업을 수행합니다.오브젝트 #등가.
개체에 대해 비교 연산자를 정말로 사용할 때는 Enum을 비교하는 경우뿐입니다.이는 Enum 값의 인스턴스가 한 번에 하나씩만 존재하기 때문입니다.예를 들어, enum이 주어집니다.
enum FooEnum {A, B, C}
한 예요.A 그것도 B ★★★★★★★★★★★★★★★★★」C 해서 을 쓸 수 뜻입니다.
public boolean compareFoos(FooEnum x, FooEnum y)
{
return (x == y);
}
그리고 당신은 어떤 문제도 없을 거야
다음은 와의 차이에 대한 일반적인 규칙의 개요입니다.
object1 == object2는 object1과 object2가 참조하는 객체가 힙 내의 동일한 메모리 위치를 참조하는지 여부를 비교합니다.
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()비교할 인스턴스 변수(예 또는 가중치)를 기준으로 정의하기 위해 사용자 클래스의 동등한 메서드를 재정의해야 합니다.
「」, 「」는== 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
코드를 평가할 때 (==)는 메모리 주소에 따라 비교하는 반면, 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
, 「 」, 「 」라고 하는 도 주의해 주세요..equals() 「」가 포함되어 있습니다.==두 물체가 동일한지 테스트하는 경우 가장 먼저 테스트해야 하는 항목이므로 테스트에 사용됩니다.
★★★★★★★★★★★★★★★★★.==에서는, 실제로는, 원시 타입의 값을 참조해, 오브젝트의 경우는 참조를 체크합니다.
== 연산자 항상 참조를 비교합니다.하지만 만약의 경우
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를 반환하고 ==도 반환한다.그러나 equal method를 덮어쓰면
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를 반환합니다.
equals method 입니다.
오브젝트의 내용(id)을 기준으로 오브젝트를 비교한다.
하지만 ==
여전히 객체의 참조를 비교합니다.
예 1 -
== 및 .disc 메서드는 모두 참조용으로만 제공됩니다.이것은 두 물체가 같은 개체를 참조하고 있는지 여부를 의미합니다.
public class HelloWorld{
public static void main(String []args){
Object ob1 = new Object();
Object ob2 = ob1;
System.out.println(ob1 == ob2); // true
System.out.println(ob1.equals(ob2)); // true
}
}
예 2 -
그러나 equals 메서드를 사용하여 객체의 콘텐츠를 비교하려면 클래스가 객체의 클래스 equals() 메서드를 덮어쓰고 콘텐츠 비교를 위한 구현을 제공해야 합니다.여기서 String 클래스는 콘텐츠 비교를 위해 동일한 메서드를 재정의합니다.모든 래퍼 클래스는 콘텐츠 비교를 위해 동일한 메서드를 재정의했습니다.
public class HelloWorld{
public static void main(String []args){
String ob1 = new String("Hi");
String ob2 = new String("Hi");
System.out.println(ob1 == ob2); // false (Both references are referring two different objects)
System.out.println(ob1.equals(ob2)); // true
}
}
예 3 -
String의 경우 유스케이스가 하나 더 있습니다.여기서 String 참조에 임의의 문자열을 할당하면 String 상수 풀 내에 문자열 상수가 생성됩니다.동일한 문자열을 새로운 String 참조에 할당하면 새로운 문자열 상수는 생성되지 않고 기존 문자열 상수를 참조합니다.
public class HelloWorld{
public static void main(String []args){
String ob1 = "Hi";
String ob2 = "Hi";
System.out.println(ob1 == ob2); // true
System.out.println(ob1.equals(ob2)); // true
}
}
일반적으로 이 메서드가 오버라이드될 때마다hashCode 메서드를 오버라이드해야 합니다.이것에 의해, 같은 오브젝트의 해시 코드가 같게 되는 것을 나타내는hashCode 메서드의 일반적인 계약이 유지됩니다.
==할 수 , 「」는 할 수 .Object.equals모유 、 [ Strings ]및 [ Google Map Markers ]를 선택합니다.
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");
}
}
}
----- 출력----- true false true
원시 타입의 래퍼 오브젝트(예: primitive type)에는 추가할 필요가 있습니다.Int, Long, Double - 두 값이 같으면 ==가 true를 반환합니다.
Long a = 10L;
Long b = 10L;
if (a == b) {
System.out.println("Wrapped primitives behave like values");
}
이와는 대조적으로, 위의 두 Long을 두 개의 개별 ArrayList에 포함시키면 는 동일한 Long을 볼 수 있지만 ==는 그렇지 않습니다.
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.");
는 연산자 하지 않기 에 Java는 연산자 오버로드를 지원하지 .==하게 동작합니다.다만, 「」는 다릅니다.equals()method는 수 은 business.is method에 따라 할 수 .
요요의 주요 ==자바에서는 다음과 같습니다."=="할 때 합니다.equals()오브젝트의 동일성을 체크하기 위해 권장되는 방법입니다.
문자열 비교는 와 메서드를 모두 사용하는 일반적인 시나리오입니다.java.lang부터.문자열 클래스 재정의는 메서드와 동일합니다. 두 String 객체에 동일한 내용이 포함되어 있지만==는 두 개의 참조가 동일한 개체를 가리키는 경우에만 true를 반환합니다.
다음으로 Java의 2개의 스트링을 비교한 예를 나타냅니다.== ★★★★★★★★★★★★★★★★★」equals()의문을 : "Method" : "Method" : "Method" : "Method" :
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);
}
}
String pool(일명 interning)과 Integer pool은 차이를 더욱 희미하게 만들 수 있으며, 이를 통해== .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()메서드는 실제로 두 개체를 비교하여 동일한 개체 값을 가지고 있는지 확인합니다.
으로는 ★★★★★★★★★★★★★★★★★」==는 2개의 객체가 히프에 동일한 참조를 가지고 있는 경우 비교하기 때문에 2개의 참조가 같은 객체에 링크되어 있지 않는 한 이 비교는 false가 됩니다.
equals()는 클래스에서 상속된 메서드입니다.이 메서드는 기본적으로 두 개체의 referrece가 동일한지 여부를 비교합니다.그 의미는 다음과 같습니다.
object1.equals(object2) <=> object1 == object2
같은 는, 할 필요가 있습니다. 이 도 매우 합니다.hashCode() 했을 equals().
hashCode()Java " " " " " " " 아직하지 않은 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().
그것은 동일성과 동등성의 차이이다.
a == ba와 b가 동일하다는 것, 즉 메모리 내의 매우 동일한 객체에 대한 기호라는 것을 의미합니다.
a.equals( b )그것들이 동등하다는 것은 어떤 의미에서는 같은 가치를 갖는 사물의 기호라는 것을 의미합니다.다만, 이러한 사물이 기억 속에서 다른 장소를 차지하고 있을 수도 있습니다.
동등성에서는 오브젝트를 평가하고 비교하는 방법에 대한 문제가 발생한다는 점에 유의하십시오.복잡한 오브젝트는 내용 중 일부가 다르더라도 실용적인 목적으로 동등하다고 간주될 수 있습니다.정체성에 대해서는 그런 질문이 없다.
로 말하면, 마로로 in in in in in in in in in in.==는, 가 같은 아닌지를 체크합니다.반면, 「메모리 위치」는 「메모리 위치」로 되어 있습니다..equals()는 오브젝트 내의 값을 비교한 것입니다.
언급URL : https://stackoverflow.com/questions/7520432/what-is-the-difference-between-and-equals-in-java
'programing' 카테고리의 다른 글
| Java/Maven에서 "Xerces hell"을 다루고 있습니까? (0) | 2022.07.24 |
|---|---|
| C와 어셈블러는 실제로 무엇을 컴파일합니까? (0) | 2022.07.24 |
| 태그 부착 구조 초기화 구문이란 무엇입니까? (0) | 2022.07.24 |
| Java 8: 스트림과 컬렉션의 퍼포먼스 (0) | 2022.07.24 |
| 일부 메서드는 조롱하지 않고 Mockito를 사용합니다. (0) | 2022.07.24 |