HashMap
Java HashMap ์ ์ด๋ป๊ฒ ๋์ํ๋๊ฐ
Java ์ HashMap
์ ํค-๊ฐ(key-value) ๊ตฌ์กฐ์ ์๋ฃ๊ตฌ์กฐ๋ก, ๋ด๋ถ์ ์ผ๋ก ๋ฐฐ์ด(Array) ๊ณผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(LinkedList), ํธ๋ฆฌ(Tree) ๋ฅผ ์กฐํฉํ์ฌ ๊ตฌํ๋์ด ์์.
ํ๊ท ์ ์ผ๋ก, ์ ์๊ฐ ๋ณต์ก๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ๊ฒ์ํ ์ ์์.
์ค๋ณต๋ ํค๋ฅผ ํ์ฉํ์ง ์๊ณ , ๊ฐ์ ์ค๋ณต๋ ์ ์์
1. HashMap ์ ๋ด๋ถ ๊ตฌ์กฐ
HashMap
์ ๋ด๋ถ์ ์ผ๋ก ๋ฐฐ์ด + ์ฐ๊ฒฐ ๋ฆฌ์คํธ + ํธ๋ฆฌ ๋ก ๊ตฌ์ฑ๋จ.
๊ธฐ๋ณธ์ ์ธ ์ ์ฅ ๊ตฌ์กฐ
๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๋, ํด์ ํจ์(Hash Function) ์ ์ด์ฉํด ํค๋ฅผ ํด์ ๊ฐ(Hash Code) ์ผ๋ก ๋ณํ
์ด ํด์ ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ๋ฐฐ์ด์ ํน์ ์ธ๋ฑ์ค(Bucket) ์ ์ ์ฅ
๊ฐ์ ์ธ๋ฑ์ค์ ์ถฉ๋(Collision) ์ด ๋ฐ์ํ๋ฉด, ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๋๋ ํธ๋ฆฌ(์๋ฐ 8์ด์) ๋ก ์ ์ฅ
HashMap<String, Integer> map = new HashMapM<();
map.put("apple", 10);
map.put("banana", 20);
map.put("cherry", 30);
์ ์ฝ๋์์ "apple"
์ ํด์ ๊ฐ์ด ๋ฐฐ์ด์ ํน์ ์ธ๋ฑ์ค(์: 5๋ฒ ์ธ๋ฑ์ค
) ๋ก ๋ณํ๋๋ฉด, ํด๋น ์์น์ ("apple", 10)
๊ฐ์ด ์ ์ฅ๋จ.
2. ํด์ ์ถฉ๋(Hash Collision) ํด๊ฒฐ ๋ฐฉ๋ฒ
ํด์ ์ถฉ๋์ด ๋ฐ์ํ๋ฉด, ๊ฐ์ ํด์ ๊ฐ์ ๊ฐ๋ ์ฌ๋ฌ ๊ฐ์ ํค๊ฐ ๊ฐ์ ๋ฒํท(Index)์ ์ ์ฅ๋ ์ ์์.
์ด ๊ฒฝ์ฐ, Java 8 ์ด์ ๊ณผ ์ดํ์ HashMap
์ ์ถฉ๋์ ์ฒ๋ฆฌํ๋ ๋ฐฉ์์ด ๋ค๋ฆ.
๐ท Java 8 ์ด์ ( Linked List
์ด์ฉ)
๋์ผํ ํด์ ๊ฐ์ด ๋์ค๋ฉด, ํด๋น ์ธ๋ฑ์ค์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Linked List) ๋์ ์๋ก์ด ๋ ธ๋ ์ถ๊ฐ.
์ถฉ๋์ด ๋ง์์ง๋ฉด ๊ฒ์ ์ฑ๋ฅ์ด O(N) ๊น์ง ๋จ์ด์ง ์ ์์
๐ท Java 8 ์ดํ( Tree ๊ตฌ์กฐ ๋์
)
์ถฉ๋์ด ์ผ์ ๊ฐ์(8๊ฐ ์ด์) ์ด์ ๋ฐ์ํ๋ฉด, ํด๋น ๋ฒํท์
Red-Black Tree(๋ ๋-๋ธ๋ ํธ๋ฆฌ)
๋ก ๋ณ๊ฒฝํธ๋ฆฌ ๊ตฌ์กฐ๋ O(log N) ์ ์ฑ๋ฅ์ ๊ฐ์ง๋ฏ๋ก ๊ฒ์ ์ฑ๋ฅ์ด ํฅ์๋จ.
// Java 8 ์ดํ, ํธ๋ฆฌ ๋ณํ ์์
HashMap<String, Integer> map = new HashMap<>();
for(int i = 0; i < 10; i++) {
map.put("key" + i, i);
}
3. HashMap ์ ์ฃผ์ ๋ฉ์๋ ๋์ ์๋ฆฌ
๐ท put(K key, V value)
ํค์
hashCode()
๋ฅผ ํธ์ถํ์ฌ ํด์ ๊ฐ ๊ณ์ฐํด์ ๊ฐ์ ๋ฐ๋ผ ๋ฐฐ์ด์ ์ธ๋ฑ์ค(Bucket) ๊ฒฐ์
๋น์ด ์์ผ๋ฉด ์๋ก์ด ๋ ธ๋ ์ถ๊ฐ, ์ด๋ฏธ ๊ฐ์ด ์์ผ๋ฉด ์ฐ๊ฒฐ ๋ฆฌ์คํธ/ํธ๋ฆฌ์ ์ ์ฅ
map.put("dog", 100); // "dog"์ ํด์ ๊ฐ์ ๊ณ์ฐํ์ฌ ํน์ ์์น์ ์ ์ฅ
๐ท get(K key)
ํค์
hashCode()
๋ฅผ ํธ์ถํ์ฌ ํด์ ๊ฐ ๊ณ์ฐํด๋น ํด์ ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ฅผ ์ฐพ์.
ํด๋น ์ธ๋ฑ์ค์ ํค๊ฐ ์กด์ฌํ๋ฉด ๊ฐ์ ๋ฐํ, ์ถฉ๋์ด ์๋ค๋ฉด ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๋๋ ํธ๋ฆฌ์์ ๊ฒ์
System.out.println(map.get("dog")); // 100
๐ท remove(K key)
ํค์ ํด์ ๊ฐ์ ๊ณ์ฐํ์ฌ ํด๋น ๋ฒํท์ ์ฐพ์.
ํค๊ฐ ์กด์ฌํ๋ฉด ํด๋น ๊ฐ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๋๋ ํธ๋ฆฌ์์ ์ญ์
map.remove("dog");
4. HashMap ์ ๋์ ํฌ๊ธฐ ์กฐ์ (Rehashing)
HashMap
์ ๊ธฐ๋ณธ ํฌ๊ธฐ(์ด๊ธฐ ๋ฒํท ์) ๋ 16 ์ด๋ฉฐ load factor(๊ธฐ๋ณธ 0.75)
๋ฅผ ์ด๊ณผํ๋ฉด ๋ฐฐ์ด ํฌ๊ธฐ๋ฅผ 2๋ฐฐ๋ก ์ฆ๊ฐ(Resizing) ์ํด .
๐ท ๋ฆฌ์ฌ์ด์ง(Resizing) ๊ณผ์
๋ฐฐ์ด ํฌ๊ธฐ๊ฐ ๋ ๋ฐฐ ์ฆ๊ฐ (์: 16 โ 32)
๋ชจ๋ ๊ธฐ์กด ํค์ ํด์ ๊ฐ์ ๋ค์ ๊ณ์ฐํ์ฌ ์๋ก์ด ๋ฒํท์ ๋ฐฐ์น
์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์ ์ฅ๋ ๋ ธ๋ฃ๋ค๋ ์๋กญ๊ฒ ์ฌ๋ฐฐ์น
HashMap<String, Integer> map = new HashMap<>(4, 0.75f); // ์ด๊ธฐ ํฌ๊ธฐ 4, load factor 0.75
map.put("a",1);
map.put("b",2);
map.put("c",3);
map.put("d",4); // ์ด๋, ํฌ๊ธฐ๊ฐ 8๋ก ์ฆ๊ฐ(Rehashing ๋ฐ์)
5. HashMap ๊ณผ HashTable ์ ์ฐจ์ด
๋น๊ต ํญ๋ชฉ
HashMap
Hashtable
๋๊ธฐํ ์ง์
โ (๋น๋๊ธฐ)
โ (๋๊ธฐํ ์ง์)
๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ
โ ์ค๋ ๋ ์์ X
โ ์ค๋ ๋ ์์
์ฑ๋ฅ
โ ๋น ๋ฆ
โ ๋๋ฆผ
null
ํ์ฉ ์ฌ๋ถ
โ
(null
ํค/๊ฐ ํ์ฉ)
โ (null
ํ์ฉ ์ํจ)
๐ ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์๋ ConcurrentHashMap
์ ์ฌ์ฉํ๋ฉด ์ข์.
Last updated
Was this helpful?