equals๋ฅผ ์ฌ์ ์ํ ํด๋์ค ๋ชจ๋์์ hashCode๋ ์ฌ์ ์ํด์ผ ํ๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด hashCode ์ผ๋ฐ ๊ท์ฝ์ ์ด๊ธฐ๊ฒ ๋์ด ํด๋น ํด๋์ค์ ์ธ์คํด์ค๋ฅผ HashMap์ด๋ HashSet ๊ฐ์ ์ปฌ๋ ์ ์ ์์๋ก ์ฌ์ฉํ ๋ ๋ฌธ์ ๋ฅผ ์ผ์ผํฌ ๊ฒ์ด๋ค. ๋ค์์ Object ๋ช ์ธ์์ ๋ฐ์ทํ hashCode์ ๋ํ ๊ท์ฝ์ด๋ค.
- equals ๋น๊ต์ ์ฌ์ฉ๋๋ ์ ๋ณด๊ฐ ๋ณ๊ฒฝ๋์ง ์์๋ค๋ฉด hashCode๋ ๋งค๋ฒ ๊ฐ์ ๊ฐ์ ๋ฆฌํดํด์ผ ํ๋ค. ์ ๋ณด๊ฐ ๋ณ๊ฒฝ๋๊ฑฐ๋, ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ค์ ์คํํ๋ค๋ฉด ๊ฐ์ด ๋ฌ๋ผ์ง ์ ์๋ค.
- ๋ ๊ฐ์ฒด์ ๋ํ equals๊ฐ ๊ฐ๋ค๋ฉด, hashCode์ ๊ฐ๋ ๊ฐ์์ผ ํ๋ค.
- ๋ ๊ฐ์ฒด์ ๋ํ equals๊ฐ ๋ค๋ฅด๋๋ผ๋, hashCode์ ๊ฐ์ ๊ฐ์ ์ ์๋ค. ํ์ง๋ง, ํด์ ํ ์ด๋ธ ์ฑ๋ฅ์ ๊ณ ๋ คํด ๋ค๋ฅธ ๊ฐ์ ๋ฆฌํดํ๋ ๊ฒ์ด ์ข๋ค.
๋ ๋ฒ์งธ์ ์ธ ๋ฒ์งธ์ ๊ท์ฝ์ ๋ํด์ ํ๋์ฉ ์์ธํ ์์๋ณด๋๋ก ํ์.
1. ๋ ๊ฐ์ฒด์ ๋ํ equals๊ฐ ๊ฐ๋ค๋ฉด, hashCode์ ๊ฐ๋ ๊ฐ์์ผ ํ๋ค. ๐ด
HashMap์ ์ด์ฉํ์ฌ ๊ฐ๋จํ๊ฒ ์์๋ฅผ ๋ค์ด๋ณด์. ์ฐ์ , HashMap์ ๋ํด์ ๊ฐ๋ตํ๊ฒ ์ค๋ช ์ ํ์๋ฉด ๊ฐ์ ๋ฃ์ ๋ hashCode()๋ผ๋ ๋ฉ์๋๋ฅผ ์คํํ์ฌ ์ด๋ ๋ฒํท์ ๋ฃ์์ง ์ ํ๊ฒ ๋๊ณ , ๊ฐ์ ๊บผ๋ผ ๋ hashCode๊ฐ์ ๋จผ์ ๊ฐ์ ธ์ค๊ณ ๊ทธ๋ฆฌ๊ณ ํด๋น ๋ฒํท์ ๋ค์ด์๋ ์ค๋ธ์ ํธ๋ฅผ ๊บผ๋ด์จ๋ค. ํด๋น ๊ฐ๋ ์ ์์งํ์๋ค๋ฉด ์๋์ ์ฝ๋๋ฅผ ์ฝ๊ฒ ์ดํดํ ์ ์์ ๊ฒ์ด๋ค.
Map<PhoneNumber, String> map = new HashMap<>();
PhoneNumber number1 = new PhoneNumber(123, 456, 7890);
PhoneNumber number2 = new PhoneNumber(123, 456, 7890);
// (1)๊ณผ (2)๊ฐ ๋ค๋ฅธ hashCode๋ฅผ ์ถ๋ ฅํ๋ค.
System.out.println(number1.hashCode()); // --- (1)
System.out.println(number2.hashCode()); // --- (2)
System.out.println(number1.equals(number2)); // true
map.put(number1, "amenable");
map.put(number2, "choi");
String s1 = map.get(number2);
System.out.println(s1); // choi
String s2 = map.get(new PhoneNumber(123, 456, 7890)); // number2์์ ์ฌ์ฉํ ๊ฒ๊ณผ ๋ค๋ฅธ ์๋ก์ด hashCode ์์ฑ
System.out.println(s2); // null
number2๋ ์ผ์ข ์ ๊ฐ ํด๋์ค์ด๋ค. ๊ฐ ํด๋์ค๋ ๋ ๋ค๋ฅธ ๊ฐ ํด๋์ค๋ฅผ ๋ฃ๋๋ผ๋ ๋์ผํ๊ฒ ๋์ํด์ผ ํ๋๋ฐ ๋ง์ง๋ง 2์ค์์ ์ ์ ์๋ฏ์ด ๊ทธ๋ ๊ฒ ๋์ํ์ง ์๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๊ฐ์ hash๊ฐ์ ๋ฆฌํดํด์ผ ํ๋ค.
2. ๋ ๊ฐ์ฒด์ ๋ํ equals๊ฐ ๋ค๋ฅด๋๋ผ๋, hashCode์ ๊ฐ์ ๊ฐ์ ์ ์๋ค. ํ์ง๋ง, ํด์ ํ ์ด๋ธ ์ฑ๋ฅ์ ๊ณ ๋ คํด ๋ค๋ฅธ ๊ฐ์ ๋ฆฌํดํ๋ ๊ฒ์ด ์ข๋ค. ๐ต
ํด์ ํ ์ด๋ธ ์ฑ๋ฅ์ ๊ณ ๋ คํ ๋ ๋ค๋ฅธ ์ธ์คํด์ค๋ ์ ๋ค๋ฅธ hashCode๋ฅผ ๋ฆฌํดํ๋ ๊ฒ์ด ์ข์์ง ์์๋ณด์. ์์์ ์ดํด๋ณธ HashMap์ ๋์ ๋ฐฉ๋ฒ์ ๊ธฐ์ตํด๋ณธ๋ค๋ฉด ์ฝ๊ฒ ์ ์ ์๋ค. ๊ฐ์ ๋ฃ์ ๋ ๋ง์ฝ hash๊ฐ์ด ํญ์ ๊ฐ๋ค๋ฉด ํ๋์ ๋ฒํท์ ๋ชจ๋ ๋ฃ์ด์ฃผ๊ฒ ๋๋ค. ์ด๋ ๊ฒ ๋๋ค๋ฉด ํด์ฌ ์ถฉ๋(Hash Collision)์ด ๋ฐ์ํ๊ฒ ๋๋ค.
๋ชจ๋ ๊ฐ์ฒด๊ฐ ํด์ํ ์ด๋ธ์ ๋ฒํท ํ๋์ ๋ด๊ฒจ ํด์ทจ ์ถฉ๋์ด ์ผ์ด๋๋ฉด ๋ง์น ์ฐ๊ฒฐ ๋ฆฌ์คํธ(linked list)์ฒ๋ผ ๋์ํ๋ค. ํ๋์ ๊ฐ์ฒด๋ฅผ ๊บผ๋ธ๋ค๊ณ ํ๋ฉด ๋ชจ๋ ๊ฐ์ฒด๊ฐ ๋ด๊ธด ๋ฒํท์ ๊ฐ์ Linked List๋ฅผ ๋ณด๋ฉด์ equals๋ก ๋น๊ตํ๊ฒ ๋๋ค. ์ด๋ ๊ฒ ๋๋ค๋ฉด HashMap์ ์ฐ๋ ์ฅ์ ์ด ํ๋๋ ์๊ณ ๊ทธ๋ฅ Linked LIst๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๊ณผ ๋๊ฐ๋ค. O(1)๋ก ๋์ํด์ผ ํ๋ ๊ฒ์ด O(n)์ผ๋ก ๋์ํ๊ฒ ๋๋ค.
๋ค์ ํ๋ฒ ์ ๋ฆฌํ์๋ฉด, ์ฑ๋ฅ์ ๊ณ ๋ คํ ๋ ๋ ๊ฐ์ฒด์ ๋ํ equals๊ฐ ๋ค๋ฅด๋ฉด hashCode๊ฐ ๋ค๋ฅธ ๊ฒ์ด ์ข๋ค๋ ๊ฒ์ด์ง, ๊ผญ ๋ฌ๋ผ์ผ ํ๋ ๊ฒ์ ์๋๋ค!
์ด๋ฒ ๊ธ์์๋ hashCode์ ๊ท์ฝ์ ๋ํด์ ์์๋ณด์๋ค. ๋ค์ ๊ธ์์๋ ์ด๋ป๊ฒ ํ๋ฉด ์ฌ๋ฐ๋ฅด๊ฒ hashCode๋ฅผ ๊ตฌํํ๋์ง ์์๋ณด์.
ํด๋น ๊ธ์ ๋ฐฑ๊ธฐ์ ๋์ '์ดํํฐ๋ธ ์๋ฐ ์๋ฒฝ ๊ณต๋ต'์ ์๊ฐํ๊ณ ์์ฑํ ๊ฒ์ ๋๋ค.