KDLiam

JAVA - HashMap ๋ณธ๋ฌธ

์ฝ”ํ…Œ ์ค€๋น„(JAVA)

JAVA - HashMap

KDLiam 2025. 10. 17. 16:06

๐Ÿš€ 1. HashMap์ด๋ž€?

HashMap์€ **Key(ํ‚ค)**์™€ Value(๊ฐ’) ์Œ์œผ๋กœ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅํ•˜๋Š” ์ž๋ฃŒ๊ตฌ์กฐ์ž…๋‹ˆ๋‹ค.
์˜ˆ๋ฅผ ๋“ค์–ด, "์‚ฌ๊ณผ" → 3๊ฐœ, "๋ฐ”๋‚˜๋‚˜" → 5๊ฐœ ๊ฐ™์€ ํ˜•ํƒœ๋กœ ์ €์žฅ๋ฉ๋‹ˆ๋‹ค.

์ฆ‰, **“์–ด๋–ค ๋ฐ์ดํ„ฐ(ํ‚ค)์— ํ•ด๋‹นํ•˜๋Š” ๊ฐ’์ด ๋ญ์•ผ?”**๋ฅผ ๋งค์šฐ ๋น ๋ฅด๊ฒŒ ์ฐพ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

ํŠน์ง•์„ค๋ช…
์ž๋ฃŒ ๊ตฌ์กฐ Key-Value ์Œ์œผ๋กœ ์ €์žฅ
์ค‘๋ณต Key๋Š” ์ค‘๋ณต ๋ถˆ๊ฐ€ / Value๋Š” ์ค‘๋ณต ๊ฐ€๋Šฅ
์ˆœ์„œ ์ €์žฅ ์ˆœ์„œ ๋ณด์žฅ ์•ˆ ๋จ
ํƒ์ƒ‰ ์†๋„ ํ‰๊ท  O(1) — ๋งค์šฐ ๋น ๋ฆ„
๋Œ€ํ‘œ ๋ฉ”์„œ๋“œ put(), get(), containsKey(), remove(), entrySet()

๐Ÿง  2. HashMap ๊ธฐ๋ณธ ๋ฌธ๋ฒ•

 
import java.util.*;

public class Main {
    public static void main(String[] args) {
        // โ‘  ์„ ์–ธ
        Map<String, Integer> map = new HashMap<>();

        // โ‘ก ๊ฐ’ ์ถ”๊ฐ€
        map.put("apple", 3);
        map.put("banana", 5);
        map.put("orange", 2);

        // โ‘ข ๊ฐ’ ๊ฐ€์ ธ์˜ค๊ธฐ
        System.out.println(map.get("apple")); // 3

        // โ‘ฃ Key ์กด์žฌ ์—ฌ๋ถ€ ํ™•์ธ
        System.out.println(map.containsKey("banana")); // true

        // โ‘ค Key ์ œ๊ฑฐ
        map.remove("orange");

        // โ‘ฅ ์ „์ฒด ์ˆœํšŒ (entrySet ์ด์šฉ)
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

โš™๏ธ 3. ์ž์ฃผ ์“ฐ๋Š” ํ•จ์ˆ˜ ์ •๋ฆฌ

๋ฉ”์„œ๋“œ | ์„ค๋ช… | ์˜ˆ์‹œ

 

Method Description Example
put(K key, V value) ๋ฐ์ดํ„ฐ ์ถ”๊ฐ€ map.put("A", 1)
get(Object key) Key์— ํ•ด๋‹นํ•˜๋Š” Value ๊ฐ€์ ธ์˜ค๊ธฐ map.get("A") → 1
getOrDefault(key, defaultValue) Key ์—†์œผ๋ฉด ๊ธฐ๋ณธ๊ฐ’ ๋ฆฌํ„ด map.getOrDefault("B", 0)
containsKey(Object key) Key ์กด์žฌ ์—ฌ๋ถ€ ํ™•์ธ true / false
remove(Object key) ํ•ด๋‹น Key ์‚ญ์ œ map.remove("A")
entrySet() Key-Value ์ „์ฒด ์Œ์„ ๋ฐ˜ํ™˜ (๋ฐ˜๋ณต๋ฌธ์— ์‚ฌ์šฉ) for(Map.Entry<K,V> e : map.entrySet())
keySet() Key๋งŒ ์ „๋ถ€ ๊ฐ€์ ธ์˜ค๊ธฐ for(K key : map.keySet())
values() Value๋งŒ ์ „๋ถ€ ๊ฐ€์ ธ์˜ค๊ธฐ for(V val : map.values())

๐Ÿ” 4. Map.Entry๋ž€?

Map์—๋Š” ์ง์ ‘์ ์œผ๋กœ “i๋ฒˆ์งธ” ์š”์†Œ๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค.
๊ทธ๋ž˜์„œ entrySet()์„ ํ†ตํ•ด Key-Value ์Œ(Entry)์„ ํ•˜๋‚˜์”ฉ ๊บผ๋‚ด๋ฉฐ ๋ฐ˜๋ณต๋ฌธ์„ ๋Œ๋ฆฝ๋‹ˆ๋‹ค.

 
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
    int key = entry.getKey();     // ํ‚ค ๊ฐ’
    int value = entry.getValue(); // ๋ฐธ๋ฅ˜ ๊ฐ’
    System.out.println(key + " : " + value);
}

์ด ๋ฐฉ์‹์€ “HashMap ์ „์ฒด๋ฅผ ๋Œ๋ฉฐ Key์™€ Value๋ฅผ ๋™์‹œ์— ํ™•์ธํ•  ๋•Œ” ๊ฐ€์žฅ ๋งŽ์ด ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.


๐Ÿงพ 5. HashMap vs ๋ฐฐ์—ด ๋น„๊ต


๊ตฌ๋ถ„๋ฐฐ์—ด Array HashMap
์ €์žฅ ๋ฐฉ์‹ ์ธ๋ฑ์Šค๋กœ ์ ‘๊ทผ Key๋กœ ์ ‘๊ทผ
์ ‘๊ทผ ์†๋„ O(1) ํ‰๊ท  O(1)
๋ฐ์ดํ„ฐ ํ˜•ํƒœ ํ•œ ๊ฐ€์ง€ ๊ฐ’๋งŒ Key-Value ์Œ
์ค‘๋ณต ๊ฐ’ ์ค‘๋ณต ๊ฐ€๋Šฅ Key ์ค‘๋ณต ๋ถˆ๊ฐ€
์ˆœ์„œ ์ธ๋ฑ์Šค ์ˆœ์„œ ์กด์žฌ ์ˆœ์„œ ๋ณด์žฅ ์•ˆ ๋จ
์‚ฌ์šฉ ์˜ˆ์‹œ ํ•™์ƒ ์ ์ˆ˜ ๋ฆฌ์ŠคํŠธ ์ด๋ฆ„๋ณ„ ์ ์ˆ˜ ์ €์žฅ, ๋นˆ๋„์ˆ˜ ๊ณ„์‚ฐ ๋“ฑ

โœ… ์š”์•ฝํ•˜์ž๋ฉด:

  • ๋ฐฐ์—ด์€ “์ˆœ์„œ๋Œ€๋กœ ์ €์žฅ, ์ธ๋ฑ์Šค๋กœ ์ ‘๊ทผ”ํ•  ๋•Œ ์œ ๋ฆฌ.
  • HashMap์€ “๋น ๋ฅธ ๊ฒ€์ƒ‰, Key-Value ๋งค์นญ”์ด ํ•„์š”ํ•  ๋•Œ ์œ ๋ฆฌ.

๐Ÿ’ก 6. ์ฝ”๋”ฉํ…Œ์ŠคํŠธ์—์„œ ์ž์ฃผ ์“ฐ์ด๋Š” HashMap ํŒจํ„ด

โœ… โ‘  ๋นˆ๋„์ˆ˜(Counting) ์„ธ๊ธฐ

 
Map<Integer, Integer> cntMap = new HashMap<>();

for (int num : array) {
    cntMap.put(num, cntMap.getOrDefault(num, 0) + 1);
}

โžก๏ธ ๋ฐฐ์—ด์˜ ๊ฐ ๊ฐ’์ด ๋ช‡ ๋ฒˆ ๋“ฑ์žฅํ–ˆ๋Š”์ง€ ์‰ฝ๊ฒŒ ๊ณ„์‚ฐ ๊ฐ€๋Šฅ.


โœ… โ‘ก ์ตœ๋นˆ๊ฐ’(๊ฐ€์žฅ ๋งŽ์ด ๋‚˜์˜จ ์ˆ˜) ์ฐพ๊ธฐ

 
int maxValue = -1;
int mode = -1;
boolean duplicate = false;

for (Map.Entry<Integer, Integer> entry : cntMap.entrySet()) {
    if (entry.getValue() > maxValue) {
        maxValue = entry.getValue();
        mode = entry.getKey();
        duplicate = false;
    } else if (entry.getValue() == maxValue) {
        duplicate = true;
    }
}

if (duplicate) System.out.println(-1);
else System.out.println(mode);

โžก๏ธ ๊ฐ™์€ ์ตœ๋นˆ๊ฐ’์ด ์—ฌ๋Ÿฌ ๊ฐœ๋ฉด -1์„ ์ถœ๋ ฅํ•˜๋„๋ก ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์Œ.


โš–๏ธ 7. ์‹œ๊ฐ„๋ณต์žก๋„ ๋น„๊ต

ํ•ญ๋ชฉ๋ฐฐ์—ด ๋ฐฉ์‹HashMap ๋ฐฉ์‹
๋นˆ๋„ ์„ธ๊ธฐ O(N) O(N)
์ตœ๋นˆ๊ฐ’ ํƒ์ƒ‰ O(1000) (๊ณ ์ • ๊ธธ์ด ๋ฐฐ์—ด) O(N)
๊ณต๊ฐ„ ๋ณต์žก๋„ ์ƒ์ˆ˜ ํฌ๊ธฐ(1000) ๋ฐ์ดํ„ฐ ํฌ๊ธฐ๋งŒํผ ๋™์  ์ฆ๊ฐ€
ํ™•์žฅ์„ฑ ๊ฐ’ ๋ฒ”์œ„๊ฐ€ ์ž‘์„ ๋•Œ ์œ ๋ฆฌ ๊ฐ’ ๋ฒ”์œ„๊ฐ€ ํด ๋•Œ ์œ ๋ฆฌ

โœ… ์ •๋ฆฌ

  • ๊ฐ’์˜ ๋ฒ”์œ„๊ฐ€ ์ž‘๋‹ค → ๋ฐฐ์—ด์ด ์œ ๋ฆฌ (์˜ˆ: 0~999 ์‚ฌ์ด ์ •์ˆ˜)
  • ๊ฐ’์˜ ๋ฒ”์œ„๊ฐ€ ํฌ๊ฑฐ๋‚˜ ๋‹ค์–‘ํ•˜๋‹ค → HashMap์ด ์œ ๋ฆฌ (์˜ˆ: ๋ฌธ์ž์—ด, ํฐ ์ˆ˜ ๋“ฑ)

๐Ÿงญ 8. ๊ฒฐ๋ก 

์ƒํ™ฉ์ถ”์ฒœ ์ž๋ฃŒ๊ตฌ์กฐ์ด์œ 
๊ฐ’์˜ ๋ฒ”์œ„๊ฐ€ ์ž‘๊ณ  ์ •์ˆ˜ํ˜• ๋ฐฐ์—ด ๋‹จ์ˆœํ•˜๊ณ  ๋น ๋ฆ„
๊ฐ’์˜ ๋ฒ”์œ„๊ฐ€ ํฌ๊ฑฐ๋‚˜ ๋‹ค์–‘ HashMap Key ๊ธฐ๋ฐ˜ ๋น ๋ฅธ ๊ฒ€์ƒ‰
๋ฌธ์ž์—ด, ๊ฐ์ฒด, ํฐ ์ˆ˜ ๋‹ค๋ฃธ HashMap ๋‹ค์–‘ํ•œ Key ํƒ€์ž… ์ง€์›

โœจ ๋งˆ๋ฌด๋ฆฌ

HashMap์€ ์ฝ”๋”ฉํ…Œ์ŠคํŠธ์—์„œ **“๋ฐ์ดํ„ฐ ๊ฐœ์ˆ˜ ์„ธ๊ธฐ”, “์ค‘๋ณต ์ฒดํฌ”, “๋น ๋ฅธ ํƒ์ƒ‰”**์— ์ž์ฃผ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.
๋ฐฐ์—ด๋ณด๋‹ค ์•ฝ๊ฐ„ ๋ฌธ๋ฒ•์ด ๋ณต์žกํ•˜์ง€๋งŒ, ์ต์ˆ™ํ•ด์ง€๋ฉด ํ›จ์”ฌ ์œ ์—ฐํ•œ ์ฝ”๋“œ๋ฅผ ์งค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

โœ… Tip:
“๋ฐฐ์—ด๋กœ ํ’€ ์ˆ˜ ์žˆ์„๊นŒ?”๋ฅผ ๋จผ์ € ์ƒ๊ฐํ•˜๊ณ ,
“๊ฐ’์˜ ๋ฒ”์œ„๊ฐ€ ํฌ๊ฑฐ๋‚˜ ๋‹ค์–‘ํ•˜๋ฉด HashMap์œผ๋กœ ์ „ํ™˜”ํ•˜๋Š” ๊ฒŒ ๊ฐ€์žฅ ํšจ์œจ์ ์ธ ์ ‘๊ทผ์ž…๋‹ˆ๋‹ค.

'์ฝ”ํ…Œ ์ค€๋น„(JAVA)' ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋‹ค๋ฅธ ๊ธ€

Sort(์ •๋ ฌ)  (0) 2025.10.17