.equals์ .hashCode()๋ ํญ์ ํจ๊ป ์ค๋ฒ๋ผ์ด๋ฉํด์ผํ๋ค.
by JiwonDevObject ๋ฉ์๋์ ์๋ .hashCode() ๋ฉ์๋๋ ํด๋น ๊ฐ์ฒด์ ์ฃผ์๊ฐ์ ์ด์ฉํ์ฌ ๋ง๋ ๊ฐ์ฒด๋ง์ ๊ณ ์ ํ ์ ์ ๊ฐ์ ๊ฐ์ง๋ค. equals()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉ ํ ๋์๋ ๋ฐ๋์ hashCode()๋ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๋ด๋๋ก ํจ๊ป ์ค๋ฒ๋ผ์ด๋ฉ ํด์ฃผ์ด์ผ ํ๋ค. ์ ๊ทธ๋ฐ์ง ์ฐจ๊ทผ์ฐจ๊ทผ ์์๋ณด๋๋ก ํ์.
Card a = new Card('ํธ๋ผํ์นด๋',10)
Card b = new Card('ํธ๋ผํ์นด๋',10)
a == b // a์ b๋ ๋ด์ฉ๋ง ๊ฐ์ ๋ฟ, ๋ค๋ฅธ ๊ฐ์ฒด๋ผ์ False๊ฐ ๋์จ๋ค.
a.equals(b) // ์ด ๊ฒฐ๊ณผ๊ฐ True ๋์ค๊ฒ ์ค๋ฒ๋ผ์ด๋ฉํ๋ค๋ฉด
a.hashCode() == b.hashCode() // ์ด ๊ฒฐ๊ณผ๋ True๊ฐ ๋์ค๋๋ก ์ค๋ฒ๋ผ์ด๋ฉํด์ผ ํ๋ค.
# ๋๋ฑ์ฑ(equality)๊ณผ ๋์ผ์ฑ(identity)
๋์ผ์ฑ์ ์์ ํ ๊ฐ์ ๊ฒ์ ์๋ฏธํ๊ณ , ๋๋ฑ์ฑ์ ๋ค๋ฅธ ๊ฐ์ฒด์ด์ง๋ง ๊ฐ์ง๊ณ ์๋ ๊ฐ(์ ๋ณด)๊ฐ ๊ฐ์์ ์๋ฏธํ๋ค.
๋์ผํ๋ค์ ๊ฒฝ์ฐ == ์ฐ์ฐ์๋ก ํ์๋๊ณ , ๋๋ฑํ๋ค์ ๊ฒฝ์ฐ equals ์ฐ์ฐ์๋ก ๋น๊ตํ๋ค.
์ฆ ๊ฐ์ฒด ๊ฐ == ์ฐ์ฐ์๋ ์ฃผ์๊ฐ์ ๋น๊ต, equals๋ ๋ด์ฉ์ ๋น๊ต๋ก ์ฌ์ฉํ๋ค.
# == ์ฐ์ฐ
( == ) ์ฐ์ฐ์ ๊ฐ ์์ฒด๋ฅผ ๋น๊ตํ๋ ์ฐ์ฐ์ด๋ค. ๋ ํผ๋ฐ์ค ํ์ ์ธ ๊ฒฝ์ฐ ๋ณ์์๋ ๊ฐ์ด ์๋ ์ฌ๋ณผ์ด ๋ค์ด๊ฐ์๊ธฐ์ ๋๋ฑ์ฑ์ด ์๋ ๋์ผ์ฑ์ ๋น๊ตํ๋ค.
์ฌ์ค ์๋ฐ์์๋ int, double ๊ฐ์ ๊ธฐ๋ณธํ ํ์ ๋ ๋ ํผ๋ฐ์ค ํ์ ์ผ๋ก ๊ด๋ฆฌ๋๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. ๋ ํผ๋ฐ์ค๋ก ๋ง๋ค๊ณ Constant Pool์ ์ค์ ๊ฐ์ ๋ฃ์ด๋๋ ๊ฒ์ด๋ค. ์ด๋ ๊ฒํ๋ฉด ์์ ๊ฐ์ ์ฌ์ฉํ ๋ ๊ฐ์ฒด๋ฅผ ์๋ก ์์ฑํ๋๊ฒ ์๋๋ผ Constant Pool ์์ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋๋ก ๋ง๋ค์ด ์ต์ ํ ์ํฌ ์ ์๋ค.
ํ์ง๋ง ์์ ๊ฐ์ด ์๋ ์์ ๋ ํผ๋ฐ์ค๋ฅผ ๋น๊ตํ๋ค ํ๋๋ผ๋ ( == )๋ฅผ ์ด์ฉํด์ ๊ฐ์ ๋น๊ตํ๋ค. ์ด์ฐจํผ ๊ฐ์ ์์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ธฐ์ ๋ ํผ๋ฐ์ค๋ฅผ ๋น๊ตํด๋ ๊ฐ์ด ๊ฐ๊ธฐ ๋๋ฌธ์ด๋ค.
clas Person { ... }
public class Main {
public static void main(String[] args) {
Person person1 = new Person("kim");
Person person2 = new Person(new String("kim"));
Person person3 = person2;
// ์ฐธ์กฐ ๊ฐ์ด ๊ฐ์ง ํฌ์ธํฐ ์ฃผ์๋ฅผ ๋น๊ตํ๋ค.
// person1 == person2 ๋ false
// person2 == person3 ๋ true
}
}
๊ทธ๋ ๋ค๋ฉด ๋์ผ์ฑ์ด ์๋ ๋๋ฑ์ฑ, ๊ฐ์ฒด๊ฐ ๊ฐ์ง ๊ฐ์ ๋น๊ตํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผํ ๊น? ์ ์ผ ์ฒ์์ ์ธ๊ธํ์ง๋ง, ์ด๋ด ๋ ์ฌ์ฉํด๋ผ๊ณ Object.equals() ๋ฉ์๋๊ฐ ์๋ ๊ฒ์ด๋ค.
# .equlas()
์ฐธ๊ณ ๋ก Object.equals() ์ ์ํ์ ( == ) ์ฐ์ฐ์ผ๋ก ๋ง๋ค์ด์ ธ์๋ค. ์ฆ ๊ฐ์ฒด์ ์ฃผ์ ๊ฐ์ ๋น๊ตํ๋ค
// Object.equals์ ์ํ.
public boolean equals(Object obj) {
return (this == obj);
}
equlas๋ ๋๋ฑ์ฑ(equality)๋ฅผ ๋น๊ตํ๋๋ฐ ์ฌ์ฉ๋๋ค. ํ์ง๋ง ์ํ์ ๋ณด๋ฉด ์๊ฒ ์ง๋ง Object ๊ฐ์ฒด๊ฐ ๊ฐ์ฒด์ ๊ฐ์ ๋ง ๋ถ์ํด์ ์๋์ผ๋ก ๋น๊ตํด์ฃผ๋ ๊ฑด ์๋๋ค. ํ์์ ๋ฐ๋ผ ์ฐ๋ฆฌ๊ฐ ์ง์ equals() ๊ฐ์ฒด๋ฅผ ์์ํ์ฌ ๊ตฌํํ์ฌ์ผํ๋ค.
# String.equals()
String๋ ๋ง์ฐฌ๊ฐ์ง๋ก ๋จ์ํ ์ฃผ์๊ฐ ๋น๊ต(==)๋ฅผ ํ๊ฒ๋๋ฉด Constant pool์ ์๋ ์์ ์คํธ๋ง์ ์ ์ ๋น๊ต๊ฐ ๋๊ฒ ์ง๋ง, new๋ฅผ ์ด์ฉํ์ฌ String ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ฉด ์ฃผ์๊ฐ์ด ๋ค๋ฅด๊ธฐ์ ์ ์ ๋น๊ต๊ฐ ๋์ง ์๋๋ค.
๊ทธ๋์ String ๊ตฌํ๋ถ๋ฅผ ์ดํด๋ณด๋ฉด Object.equals()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ์ฌ ์๋กญ๊ฒ ์ ์ํ ๊ฒ์ ๋ณผ ์ ์๋ค. String.equals() ๋ฉ์๋๋ ๊ฐ์ฒด๊ฐ ๊ฐ์ง ๋ฌธ์์ด์ ํ ๊ธ์์ฉ ๋น๊ตํ์ฌ ๋์ผํ๋ค๋ฉด true๋ฅผ ๋ฐํํ๋๋ก ์ค๋ฒ๋ผ์ด๋ฉ ๋์ด์๋ค.
# ๊ฐ์ฒด์ hashCode()
๊ฐ์ฒด๊ฐ ๊ฐ์ง hashCode๋ ์ผ์ข ์ ๊ฐ์ฒด ์ง๋ฌธ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค. ๊ทธ ๊ฐ์ฒด์ ๊ฐ์ ๋ํํ๋ ๊ฑด๋ฐ, ๊ธฐ๋ณธ ๊ตฌํ์ ๊ฐ์ฒด์ ์ฃผ์์ hashํจ์๋ฅผ ์ ์ฉ์์ผ ๋ง๋ ๋ค. ๊ทธ๋์ ์ด๋ฆ์ด ํด์ฌ์ฝ๋. (์ฃผ์๊ฐ์ ๊ทธ๋๋ก ๊ฐ์ ธ์ ์ฐ๋๊ฑด ์๋๊ณ ์ฌ์ฉํ๊ธฐ ์ข๊ฒ ๋ณํํ๋ค.)
* ์ฐธ๊ณ ๋ก Object.hashCode()๋ native ๋ฉ์๋์ด๋ค.
์ด๋ฅผ ์ฝ๊ฒ๋งํ๋ฉด, ์๋ฐ ์ฝ๋์์์๋ .hashCode() ์ ์ธํฐํ์ด์ค๋ง ์ ํ์์ ๋ฟ ๊ตฌํ์ฒด๋ ์๋ค.
public class Object {
public native int hashCode(); // ์ธํฐํ์ด์ค๋ง๋ฅ ๊ตฌํ๋ถ๊ฐ ์์.
}
์ด๋ ๊ฒ native ํค์๋๋ฅผ ์ฌ์ฉํ๋ฉด, ์ธ๋ถ์์ ๋ค๋ฅธ ์ธ์ด๋ก ์ปดํ์ผ๋ ๋ค์ดํฐ๋ธ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์๋๋ฐ ์๋ฐ์ hashCode() ๋ฉ์๋๋ ์ด์์ฒด์ ์ ์์ฑ๋์ด์๋ ๋ฉ์๋(๋ณดํต C์ธ์ด๋ก ์์ฑ๋์ด ์๋ค.)๋ฅผ ์ด์ฉํด hashCode ๋ฉ์๋๋ฅผ ๊ฐ์ ธ์ ์ฌ์ฉํ๋ค.
์ฐธ๊ณ ๋ก ์๋ฐ์์ ์๋ฐ๊ฐ ์๋ ์ธ์ด๋ฅผ ์ฌ์ฉํ๋ JNI๋ผ๋ ๊ธฐ์ ์ด ์๋ค. ์ด๋ ๊ถ๊ธํ๋ฉด ์ง์ ์ฐพ์๋ณด์.
clas Person { ... }
public class Main {
public static void main(String[] args) {
Person person1 = new Person("kim");
Person person2 = new Person(new String("kim"));
Person person3 = person2;
System.out.println("person1.hashCode() = " + person1.hashCode());
System.out.println("person2.hashCode() = " + person2.hashCode());
System.out.println("person3.hashCode() = " + person3.hashCode());
// person1.hashCode() = 1349414238
// person2.hashCode() = 321142942
// person3.hashCode() = 321142942 ์ฃผ์๊ฐ ๊ฐ์ผ๋ฉด hashCode๋ ๊ฐ๋ค.
}
}
# String์ hashCode()
ํ์ง๋ง String์ ๊ฒฝ์ฐ๋ ์กฐ๊ธ ๋ค๋ฅด๋ค. String ๊ฐ์ฒด๊ฐ ๊ฐ์ง ์ฃผ์๊ฐ์ด ์๋๋ผ ๋ฌธ์์ด์์ ํ ๊ธ์์ฉ ๊ฐ์ ธ์ ๋ณํํ์ฌ String ๊ฐ์ฒด๊ฐ์ ๋์ผ์ฑ์ ๋น๊ตํ๋ hashCode()๋ฅผ ์์ฑํ๋ค. ์ฆ ์ฃผ์๊ฐ ์๋ ๋ฌธ์์ด ๋ด์ฉ ์์ฒด๋ฅผ ๋น๊ต(=๋๋ฑ์ฑ ๋น๊ต)ํ๋ hashCode๋ฅผ ์์ฑํ๋ ์ .
์ฐธ๊ณ ๋ก ์๋ฐ๋ 32๋นํธ ์ด์์ฒด์ ๋ง ์ฌ์ฉํ ๋ ๊ฐ๋ฐ๋ ์ธ์ด๋ผ 32๋นํธ ์ฃผ์๊ฐ์ ์ด์ฉํด์ ํด์ฌํจ์๋ฅผ ๋ง๋ ๋ค. 64๋นํธ ์ด์์ฒด์ ์ ๊ฒฝ์ฐ ์ฃผ์๊ฐ์ ์ ๋ฐ๋ง ์ฌ์ฉํ๋๋ฐ, ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ต๋ํ ๊ฒน์น์ง ์๊ฒ ๋ง๋ค์์ด๋ ์ ๋ง ์ ๋ง ๋ฎ์ ํ๋ฅ ๋ก ๊ฐ์ ์ฃผ์๊ฐ์ด 2๊ฐ ๋์ฌ ์ ์๋ค๋๊ฑธ ์์์ผ๋ก ์๊ณ ๋ง ์์. ์ฃผ์๊ฐ์ด ๊ฐ์ผ๋ฉด ๋น์ฐํ ํด์ฌ์ฝ๋์ ๊ฐ๋ ๊ฐ๋ค. (๊ทธ๋ฐ๋ฐ ์ฌ์ค์ ์ผ์ด๋ ํ๋ฅ ์ด 0์ ๊ฐ๊น๊ณ 64๋นํธ๋ก ๋ฐ๊ฟจ์ ๋ ์ฑ๋ฅ์ด ํ๋ฝํด์ ๊ทธ๋๋ก 32๋นํธ ์ฃผ์์ฒด๊ณ๋ก ์ฌ์ฉํ๊ณ ์๋ค๊ณ ํ๋ค.)
์ฐธ๊ณ ๋ก hashCode๋ฅผ ๋ง๋๋ ํด์ฌํจ์ ์์์ ๋ง๋ค ๋ ์ซ์ 31์ ์์ฃผ ์ฌ์ฉํ๋ค.
๊ทธ ์ด์ ๋ ๋ง๋ค์ด์ง hashCode๋ฅผ ์ฌ์ฉํ ๋ ์ฐ์ฐ ์ฑ๋ฅ์ ์กฐ๊ธ์ด๋๋ง ํฅ์์ํค๊ธฐ ์ํจ์ธ๋ฐ, ๋ฌด๊ฑฐ์ด ๊ณฑ์ ์ฐ์ฐ์ ๋บ์ ์ผ๋ก ๋ฐ๊ฟ ์ต์ ํ ํ๊ธฐ ์ํด ์ ๋นํ ์ซ์๋ฅผ ๊ณฑํด ๋นํธ๋ฅผ ์ผ์ชฝ์ผ๋ก ์ฌํํธ ํด์ผํ๋๋ฐ 31์ด ์์ + ํ์ + 2์ ๋ฐฐ์($2^5 -1)$ ์ธ ์๋ฒฝํ ์ซ์์ด๊ธฐ ๋๋ฌธ์ด๋ค.
- 2์ ๋ฐฐ์๋ ์ ์ด์ ๋ชฉ์ ์ด ๋นํธ ์ฌํํธ (00011 -> 01100)๋ฅผ ์ด์ฉํ ํด์ฌ์ฝ๋์ ์ฐ์ฐ ์ต์ ํ๋ผ์ ๊ทธ๋ ๋ค.
- ๋ถํธํ๊ฒ 2์ ๋ฐฐ์(์ง์)๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ์ง ์๊ณ -1 ํด์ ํ์๋ฅผ ์ฌ์ฉํ๋๊ฑด ํ์ชฝ์ด 0์ผ๋ก ๊ณ ์ ๋๋๊ฑธ ๋ฐฉ์งํ๊ธฐ ์ํจ์ด๋ค. ํด์์ฝ๋๋ฅผ ๋ง๋๋ ๊ณผ์ ์์ ์ง์๋ฅผ ์ฌ์ฉํ๊ฒ๋๋ฉด ์ฐ์ฐํ ๋ ๋ง๋ค ์ค๋ฅธ์ชฝ์ 0์ด ๊ณ์ํด์ ์ถ๊ฐ๋์ด (5120000000) ๊ฐ์ ๊ฐ์ด ๋์ค๊ธฐ ๋๋ฌธ์ด๋ค.
- ๋นํธ ์ฌํํธ์ ๊ตณ์ด ์์๋ฅผ ์ด์ฉํ๋ ๊ฑด..์ฌ์ค ๋ณ ์ด์ ๊ฐ ์๋ค. ๊ทธ๋ฅ ์์๋ฅผ ์ฐ๋ฉด ์๊ณ ๋ฆฌ์ฆ์ ์ข์๊ฑฐ ๊ฐ๋ค๋ ๋ฏธ์ ๋๋ฌธ์ด๋ค. (์ค์ JVM ๊ฐ๋ฐ์๊ฐ ์ธ๊ธํ ๋ง์ด๋ค.)
# equals()์ hashcode()์ ๋์์ ๊ฐ์์ผ ํ๋ค.
์ด๋ ์ผ์ข ์ ๊ท์น์ด๋ค. ๋ฌผ๋ก ์งํค์ง ์๋๋ค๊ณ ํ๋ก๊ทธ๋จ์ด ๋ฉ์ถ๊ฑฐ๋ ์ปดํ์ผ ํ์์ ์์ธ๊ฐ ๋ฐ์ํ๋ ๊ฑด ์๋๋ค. ์ด๋ ๊ฒ ํด์ผํ๋ ์ด์ ๋ ์ฝ๋์ ํ์ฅ์ฑ ๊ฐ์ ์ถ์์ ์ธ ์ด์ ๋ ์๊ฒ ์ง๋ง ์ ์ผ ์ค์ํ๊ฑด ์๋ฐ์ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ, ์ปฌ๋ ์ ํ๋ ์์ํฌ๊ฐ hashCode()์ equals()๋ฅผ ๋ ๋ค ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ด๋ค.
์ปฌ๋ ์ ํ๋ ์์ํฌ์์ ์ฌ์ฉํ๋ hashCode() ์ equals()๋ฅผ ์ดํด๋ณด์. ์ดํดํ๊ธฐ ์ฝ๊ฒ HashMap์์ ํค ๊ฐ์ ์๋ก ์ ๋ ฅํ ๋, ์ค๋ณต๋ ํค๊ฐ ์๋์ง ๋น๊ตํ๋ ์ฐ์ฐ์ ํ๋ค๊ณ ๊ฐ์ ํ๊ฒ ๋ค.
- hashCode()
๋ฉ์๋๋ฅผ ์คํํด์ ๋ฆฌํด๋ hashCode() ๊ฐ์ด ๊ฐ์์ง ๋ณธ๋ค. ๋ง์ฝ ๋ค๋ฅด๋ค๋ฉด ๋ค๋ฅธ ๊ฐ์ฒด๋ก ํ๋จํ๋ค. - hashCode() -> equals()
hashCode์ ๊ฐ์ด ๊ฐ๋ค๋ฉด equals(~)๋ก ๋ค์ ๋น๊ตํ๋ค. ์ด ๋ ๊ฐ๊ฐ ๋ชจ๋ ๋ง์์ผ ๋๋ฑํ ๊ฐ์ฒด๋ก ํ๋จํ๋ค.
๋ง์ฝ hashCode์ ๊ฐ์ด ๋ค๋ฅด๋ฉด ๋น๊ต ์ฐ์ฐ ์์ฒด๋ฅผ ํ์ง์์์ ์ ์ํ์
๋ง์ฝ equals()๋ฅผ ๋ณ๊ฒฝํ์ง ์์๋ค๋ฉด, ( == ) ๋ฅผ ์ด์ฉํด์ ๋์ผ์ฑ ๋น๊ต๋ฅผ ํ๊ธฐ ๋๋ฌธ์ ํด๋น ์์ ์ ์๋ฌด๋ฐ ๋ฌธ์ ๊ฐ ์๋ค. ํ์ง๋ง ๋ด ๊ฐ์ฒด์ ๋น๊ต๋ฅผ ์ํด equals()๋ฅผ ์์ ํ๋ค๋ฉด ๋ฐ๋์ hashCode() ๋น๊ต๋ ๊ฐ์ ๋์์ ํ๋๋ก ํด์ํจ์๋ฅผ ์์ ํด์ผํ๋ค.
๊ทธ๋ ๊ฒ ํ์ง์๋๋ค๋ฉด ์ปฌ๋ ์ ํ๋ ์์ํฌ๋ฅผ ํฌํจํ ๋ง์ ์๋ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ ๋๋ก๋ ๋น๊ต ๋์์ ํ์ง ๋ชปํ๊ฒ ๋๋ค.
# equals๋ฅผ ์ฌ์ ์ ํ๋ ค๊ฑฐ๋ hashCode๋ ์ฌ์ ์ ํด์ผํ๋ค.
๊ฒฐ๋ก ์ด๋ค.
- ๋์ผ์ฑ(==)์ด ์๋ ๋๋ฑ์ฑ(.equals)์ ๋น๊ตํ๋ ค๋ฉด Object.equals()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉ ํด์ผํ๋ค.
- ๋จ, equals()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ๋ค๋ฉด ๋ฐ๋์ hashCode() ๋น๊ต๋ ๋์ผํ ๋์์ ํ๋๋ก ์ค๋ฒ๋ผ์ด๋ฉ ํ๋ค.
- ์ฆ [ A.equals(B) ]๊ฐ True๋ผ๋ฉด [ A.hashCode() == B.hashCode ]๋ True๊ฐ ๋๋๋ก ๋ง๋ค์ด์ผ ํ๋ค.
Card a = new Card('ํธ๋ผํ์นด๋',10)
Card b = new Card('ํธ๋ผํ์นด๋',10)
a == b // a์ b๋ ๋ด์ฉ๋ง ๊ฐ์ ๋ฟ, ๋ค๋ฅธ ๊ฐ์ฒด๋ผ์ False๊ฐ ๋์จ๋ค.
a.equals(b) // ์ด ๊ฒฐ๊ณผ๊ฐ True ๋์ค๊ฒ ์ค๋ฒ๋ผ์ด๋ฉํ๋ค๋ฉด
a.hashCode() == b.hashCode() // ์ด ๊ฒฐ๊ณผ๋ True๊ฐ ๋์ค๋๋ก ์ค๋ฒ๋ผ์ด๋ฉํด์ผ ํ๋ค.
hashCode()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ ๋์๋ Object.hash( ๊ฐ )์ ์ด์ฉํด ํด์ํจ์๋ฅผ ๊ตฌํํด๋ ๋๋๋ฐ, ์ฌ์ค ์ง์ ๋ง๋ค์ด๋ ํฌ๊ฒ ์ด๋ ต์ง ์๋ค. ์ฐธ๊ณ ๋ก ์ดํด๋ฆฝ์ค์ ์ธํ ๋ฆฌ์ ์ด๋ equals์ hashcode๋ฅผ ์๋ ์์ฑํ๋ ๊ธฐ๋ฅ์ ๊ฐ์ง๊ณ ์๋ค.
@Override
public boolean equals(Object obj) {
// equals๋ฅผ kind ์ number๋ฅผ ์ด์ฉํ์ฌ ๋น๊ตํ๋๋ก ์ค๋ฒ๋ผ์ด๋ฉํ์๋ค.
if (!(obj) instanceof Card) {
return false;
}
Card c = (Card)obj;
return this.kind.equals(c.kind) && this.number == c.number
}
@Override
public int hashCode() {
// ๊ทธ๋ ๋ค๋ฉด ๋ฐ๋์ hashCode()๋ kind์ number๋ฅผ ์ด์ฉํ์ฌ ๋ง๋ค์ด์ผํ๋ค.
// ์ฆ ํด์์ฝ๋ ๋น๊ต๊ฐ equals์ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋๋ก ๊ตฌํํด์ผ ํ๋ค.
return Object.hash(kind, number)
}
hashCode๋ฅผ ์ ๋ง๋๋ ๊ฟํ(Effetive Java 3ํ)
'๐๊ธฐ๋ณธ ์ง์ > Java ๊ธฐ๋ณธ์ง์' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ฐ๋ ๋ ๋๊ธฐํ (sync, volatile, AtomicClass) (0) | 2021.07.27 |
---|---|
์๋ฐ์ String๊ณผ Constant Pool (2) | 2021.07.27 |
์ ๋ค๋ฆญ(Generic)์ ๋ํ์ฌ (0) | 2021.07.26 |
์๋ฐ์์ Stack Memory & Heap Memory (0) | 2021.07.10 |
JVM(์๋ฐ๊ฐ์๋จธ์ )๊ณผ JRE, JDK (0) | 2021.06.30 |
๋ธ๋ก๊ทธ์ ์ ๋ณด
JiwonDev
JiwonDev