๐ค ์ด ๊ธ์ ์์ฑ์์ ์ดํด๋ฅผ ๋ฐํ์ผ๋ก ์์ฑ๋์ด์์ต๋๋ค. ์ค๋ฅ๋ ์๋ชป๋์ ๋ณด๊ฐ ์์ ์ ์์ต๋๋ค.
"equals์ hashcode๋ ๊ฐ์ด ์ฌ์ ์ ๋์ด์ผํ๋ค."
Java๋ฅผ ์ฒ์ ์ ํ์๋ ์ ์ ์๋์๋๊ฒ๋ค์ค ํ๋๊ฐ String์ ๋น๊ตํ ๋๋
==
๋ฑํธ ๋น๊ต๊ฐ์๋String.equals(str)
๋ฉ์๋๋ฅผ ์ด์ฉํ ๋น๊ต์๋ค.
String a =new String("๋์ผ์ฑ");
String b =new String("๋์ผ์ฑ");
System.out.println(a==b);// false
๊ฐ์ฒด๋น๊ต์ ==
์ฐธ์กฐํ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋น๊ตํ๊ฒ๋๋ค.(์ด๊ธ์์๋ ์ค๋ช
์ ์๋ต) ๋ฉ๋ชจ๋ฆฌ๊ฐ ๊ฐ๋ค๋ฉด ์ด๋ ๋์ผ์ฑ
์ ๋ง์กฑํ๋ค.
์ฐ๋ฆฌ๊ฐ String ์ด๋ ๊ธฐํ ๋ค๋ฅธ๊ฐ์ ๋น๊ตํ ๋ ๋ฌธ์์ด ๊ฐ ์์ฒด์ ๋น๊ต๋ฅผ ์ํ ๊ฒ์ด๋ค. ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ค๋ฅด๋๋ผ๋ ๊ฐ์ด ๊ฐ์๊ฒฝ์ฐ ์ฆ ๋๋ฑ
ํ์ง ๋น๊ตํ๊ณ ์ ํ๋ค. ๊ฐ์ ์ผ์น์ฌ๋ถ๋ฅผ ๋์ผ์ฑ ์ด๋ผํ๋ค
Object class ์์ ์์๋ฐ์ equals ๋ฉ์๋๋ฅผ String ์ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ ์ ํ๋ค.
//java 1.8์์ String ์ฝ๋์
๋๋ค. ์ด๋ ์๋ฐ ๋ฒ์ ์ ๋ฐ๋ผ ๋ค๋ฅผ์๋ ์์ต๋๋ค. ๐
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
์ฝ๋๋ฅผ ์งง๊ฒ ๋ถ์ํด๋ณด์๋ฉด ์ฒซ if๋ฌธ์์๋ ๋์ผ์ฑ์ ๋น๊ตํ๋ค. ๊ฐ๋น
๊ต์ด์ ์ ๋์ผํ ๊ฐ์ฒด์ผ๊ฒฝ์ฐ๋ ํญ์ ์ฐธ์ด๊ธฐ๋๋ฌธ์ด๋ค.
๋๋ฒ์งธ if๋ถ๊ธฐ์์ instanceof ๋ก ๊ฐ์ฒดํ์
์ ๊ฒ์ฌํ๊ณ String์ผ ๊ฐ์ char[] ๋ฐฐ์ด๋ก ์ํํ๋ฉด์ ๋๋ฑ์ฑ์ ๋น๊ตํ๋ค.
์๋ฐ object๋ ๊ฐ ๊ณ ์ ์ hash์ฝ๋๋ฅผ ๊ฐ์ง๋ฉฐ ์ด๋ Object ํด๋์ค์ ๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํด์ ์ ์ํ๋ค.
์ผ๋ฐ์ ์ผ๋ก hashcode๋ ๊ฐ์ฒด์ ์ฃผ์๊ฐ์ ๋ณํํ์ฌ ์์ฑํ ๊ฐ์ฒด์ ๊ณ ์ ์ ์๊ฐ์ด ์ฌ์ฉ๋๋ฉฐ ๋ ๊ฐ์ฒด๊ฐ ๋์ผ ๊ฐ์ฒด์ธ์ง ๋น๊ต ํ ๋ ์ฌ์ฉ๋๋ค. (๋์ผ์ฑ)
hashcode๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ฒด๊ฐ ๋์ผ๊ฐ์ฒด์์ ๋น๊ตํ๋๋ฐ ๋จ์๊ฐ์ผ๋ก ๋น๊ตํ๋ฉด ๋๋ฏ๋ก O(1) ์๊ฐ๋ณต์ก๋๋ก ๋น๊ตํ ์์๋ค.
HashMap,HashSet ๋ฑ JCF(Java Collection Framework) ์์ ๊ฐ์ฒด๊ฐ์ ๋์ผ์ฑ์ ๋น๊ตํ ๋ ์ฌ์ฉ๋๋ค.
public class IDCard {
String owner;
@Override
public boolean equals(Object obj) {
if (this==obj){
return true;
}
if (obj instanceof IDCard){
return this.owner.equals(((IDCard) obj).owner);
}
return false;
}
}
ํ ์คํธ์ ์ฌ์ฉ๋ ์ฝ๋์ด๋ค. ๊ฐ๋จํ๊ฒ IDCard๋ผ๋ ํด๋์ค๋ฅผ ์์ฑํ๋ค. ์ด ํด๋์ค๋ฅผ ํตํด equals์ hashcode์ ๊ดํ ํ ์คํธ ๋ช๊ฐ์ง๋ฅผ ์งํํ๋ ค ํ๋ค.
// ๋๋ฑ์ฑํ
์คํธ
@Test
void equals_test(){
//given
IDCard a_card=new IDCard("์ง๋ฏผ");
IDCard b_card=new IDCard("์ง๋ฏผ");
//when
assertEquals(a_card,b_card);
//then
}
์์๋๋ก ์ํต๊ณผํ๋ค.
// set์ ์ด์ฉํ ์ค๋ณต์ ๊ฑฐ ํ
์คํธ
@Test
void equals_noHashcode(){
//given
IDCard a_card=new IDCard("์ง๋ฏผ");
IDCard b_card=new IDCard("์ง๋ฏผ");
//when
Set<IDCard> card_set=new HashSet<>();
card_set.add(a_card);
card_set.add(b_card);
assertEquals(a_card,b_card);
assertEquals(1,card_set.size());
}
equals๋ก ๋น๊ตํ์๋ ๊ฐ๋ค(๋๋ฑ) ํ๊ธฐ์ Set์ผ๋ก๋ ์ค๋ณต์ ๊ฑฐ๊ฐ ๋์ด์ผ ํ๋๊ฑธ ์๊ฐํ๋ค.
๊ฐ๋ตํ๊ฒ ๋งํ๋ฉด HashMap, HashSet ๋ฑ์ ๊ฐ์ฒด์ hashcode๋ฅผ ์ด์ฉํด ๋จผ์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๊ณ ๊ทธํ equals ๋น๊ต๋ฅผ ํตํด์ ๊ฐ์ฒด๊ฐ ๊ฐ์์ง์ฌ๋ถ๋ฅผ ํ๋จํ๋ค. ์ฆ ์์ฌ ์ฝ๋๋ ๋ค์๊ณผ๊ฐ๋ค.
if (a.hashcode!=b.hashcode){
return false
}
else{
return a.equals(b)? true:false
}
hashcode๋ฅผ ์ฌ์ ์ ํ์ง์์๊ฒฝ์ฐ ์์ ํด๋์ค์ธObject์ hash์ฝ๋์ธ ๋ฉ๋ชจ๋ฆฌ๊ฐ์์ํ hashcode๋ฅผ ์์ฑํ๋ค. ์ด๊ฒฝ์ฐ ๊ฐ์ฒด์ ์ฃผ์๋ก ๋์ผ์ฑ์ ์ฒดํฌํ๋ฏ๋ก ๋๋ฑ์ฑ ๋น๊ต์ด์ ์ hash์ฝ๋์์ ์ด๋ฏธ ๊ฐ์ง์์์ด ํ๋ช ๋ ๋ค๋ฅธ๊ฐ์ผ๋ก ํ๋จํ๋ค.
public class IDCard2 extends IDCard{
public IDCard2(String owner) {
super(owner);
}
@Override
public boolean equals(Object obj) {
return super.equals(obj);
}
@Override
public int hashCode() {
return this.owner.hashCode();
}
}
IDCard ํด๋์ค๋ฅผ ์์๋ฐ๋ IDCard2 ํด๋์ค๋ฅผ ๋ง๋ค๊ณ hashcode๋ก๋ String ์ธ owner๋ฅผ ์ฌ์ฉํจ์ผ๋ก์จ String.hashcode๊ฐ ๋์ํ๋๋กํ๋ค.
IDCard2๋ฅผ ์ฌ์ฉํ ๊ฐ์ฒด๋ ๊ฐ owner์ ์ด๋ฆ์ด ๊ฐ๋ค๋ฉด ๊ฐ์ hashcode๋ฅผ ์์ฑํ๋๋ก ๋ณ๊ฒฝํ๋ค.์ด๋ก Set์์๋ ์ค๋ณต์ ๊ฑฐ๊ฐ ์๋ ํ ์คํธ๋ฅผ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ ์ ์์๋ค.
JCF(java colleciton framework)๋ฅผ ์ด์ฉํ๊ธฐ์ํด์ hashcode ์ฌ์ ์๊ฐ ํ์์ ์ด๋ค. ๋ง์ฝ ๋จ์ ๊ฐ์ฒด๋ง ์ฌ์ฉํ ๊ฑฐ๋ผ hashcode ๋ฅผ ์ฐ์ง์๋๋ค๋ฉด ์ ์ํ์ง์์๋ ๋น์ฅ์ ์ฝ๋์ ๋ฌธ์ ๋ฅผ ์ผ์ผํค์ง ์๊ฒ ์ง๋ง ์ ์ฌ์ ์ธ ์ฝ๋์ ๋ณ์น์ฑ์ ์ ๋ฐํ ๊ฒ์ด๋ค.
์ ์ฌ์ ์ํ์ ๋ฐ๊ฒฌํ๋๋ฐ ๋ฐฉ์นํ๋๊ฑด ๋ณ๋ก ์ข์ง์๋ค๋ ๊ฐ์ธ์ ์ธ ์๊ฐ์ด๋ค.
์ถ๊ฐ์ ์ผ๋ก
Lombok ์ ์ฌ์ฉ์ค์ด๋ผ๋ฉด @EqualsAndHashCode ์ด๋
ธํ
์ด์
์ ํตํด ๊ฐํธํ๊ฒ ์ฌ์ ์ํ ์์๋ค.
์ข์ ์ ๋ณด ๊ฐ์ฌํฉ๋๋ค