๐ก ๊ณต๋ถํ๊ฒ ๋ ๋ฐฐ๊ฒฝ
์ฝ๋ฉํ
์คํธ๋ฅผ ์ค๋นํ๋ ค๊ณ ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์ ๋ฅผ ํ๊ณ ์์๋ค. ๋ฌธ์ ๋ฅผ ํ๋ค ๋ณด๋ ํน์ ๊ฐ์ ๋น๋์๋ฅผ ์ธ๊ฑฐ๋, ๋น ๋ฅด๊ฒ ํ์ํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ์์ฃผ ๋ฑ์ฅํ๋ค.
์ด๋ฐ ์ํฉ์์ HashMap์ ์์ง ๋ชปํ๋ฉด ๊ตฌํ ์์ฒด๊ฐ ์ด๋ ต๋ค๋ ๊ฑธ ๋๊ผ๊ณ , “์ด์ฐธ์ ๊ฐ๋
๋ถํฐ ์ ๋๋ก ์ก์!”๋ ๋ง์์ผ๋ก HashMap์ ๊ณต๋ถํ๊ฒ ๋์๋ค.
๐ฆ HashMap,, ๊ทธ๋์ ๊ทธ๊ฒ ๋๋์ฒด ๋ญ๋ฐ?!
HashMap์ Map ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๋ํ์ ์ธ Map ์ปฌ๋ ์
์ด๋ค.
Map ์ธํฐํ์ด์ค๋ฅผ ์์ํ๊ณ ์๊ธฐ์ Map์ ์ฑ์ง์ ๊ทธ๋๋ก ๊ฐ์ง๊ณ ์๋ค. Map์ ํค์ ๊ฐ์ผ๋ก ๊ตฌ์ฑ๋ Entry๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ์ฌ๊ธฐ์ ํค์ ๊ฐ์ ๋ชจ๋ ๊ฐ์ฒด์ด๋ค. ๊ฐ์ ์ค๋ณต ์ ์ฅ๋ ์ ์์ง๋ง ํค๋ ์ค๋ณต ์ ์ฅ๋ ์ ์๋ค.
๋ง์ฝ ๊ธฐ์กด์ ์ ์ฅ๋ ํค์ ๋์ผํ ํค๋ก ๊ฐ์ ์ ์ฅํ๋ฉด ๊ธฐ์กด์ ๊ฐ์ ์์ด์ง๊ณ ์๋ก์ด ๊ฐ์ผ๋ก ๋์น๋๋ค. HashMap์ ์ด๋ฆ ๊ทธ๋๋ก ํด์ฑ(Hashing)์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ๋ ๋ฐ ์์ด์ ๋ฐ์ด๋ ์ฑ๋ฅ์ ๋ณด์ธ๋ค.
๐ ํค์ ๊ฐ์ด ๋ญ์ผ?
- Key: ์๋ณ์ (์ค๋ณต โ)
- Value: ์ค์ ์ ์ฅ๋๋ ๋ฐ์ดํฐ (์ค๋ณต ๊ฐ๋ฅ โ )
๐ HashMap ์ฌ์ฉ๋ฒ
HashMap<String,String> map1 = new HashMap<String,String>(); // HashMap ์์ฑ
HashMap<String,String> map2 = new HashMap<>(); // new์์ ํ์
ํ๋ผ๋ฏธํฐ ์๋ต๊ฐ๋ฅ
HashMap<String,String> map3 = new HashMap<>(map1); // map1์ ๋ชจ๋ ๊ฐ์ ๊ฐ์ง HashMap ์์ฑ
HashMap<String,String> map4 = new HashMap<>(10); // ์ด๊ธฐ ์ฉ๋(capacity) ์ง์
HashMap<String,String> map5 = new HashMap<>(10, 0.7f); // ์ด๊ธฐ capacity,load factor ์ง์
HashMap์ ์์ฑํ๋ ค๋ฉด ํค ํ์
๊ณผ ๊ฐ ํ์
์ ํ๋ผ๋ฏธํฐ๋ก ์ฃผ๊ณ ๊ธฐ๋ณธ์์ฑ์๋ฅผ ํธ์ถํ๋ฉด ๋๋ค.
HashMap์ ์ ์ฅ๊ณต๊ฐ๋ณด๋ค ๊ฐ์ด ์ถ๊ฐ๋ก ๋ค์ด์ค๋ฉด List์ฒ๋ผ ์ ์ฅ๊ณต๊ฐ์ ์ถ๊ฐ๋ก ๋๋ฆฌ๋๋ฐ List์ฒ๋ผ ์ ์ฅ๊ณต๊ฐ์ ํ ์นธ์ฉ ๋๋ฆฌ์ง ์๊ณ ์ฝ ๋๋ฐฐ๋ก ๋๋ฆฐ๋ค. ์ฌ๊ธฐ์ ๊ณผ๋ถํ๊ฐ ๋ง์ด ๋ฐ์ํ๋ค. ๊ทธ๋ ๊ธฐ์ ์ด๊ธฐ์ ์ ์ฅํ ๋ฐ์ดํฐ ๊ฐ์๋ฅผ ์๊ณ ์๋ค๋ฉด Map์ ์ด๊ธฐ ์ฉ๋์ ์ง์ ํด ์ฃผ๋ ๊ฒ์ด ์ข๋ค.
๐ ์ฃผ์ ๋ฉ์๋ ์ ๋ฆฌ
- put(K key, V value): ์๋ก์ด ํค-๊ฐ ์์ ์ถ๊ฐํ๋ค.
์ด๋ฏธ ์กด์ฌํ๋ ํค๋ผ๋ฉด ํด๋น ํค์ ๊ฐ์ ์๋ก์ด ๊ฐ์ผ๋ก ๋ฎ์ด์ด๋ค. - get(Object key): ํด๋น ํค์ ๋์ํ๋ ๊ฐ์ ๋ฐํํ๋ค.
์กด์ฌํ์ง ์๋ ํค์ผ ๊ฒฝ์ฐ null์ ๋ฐํํ๋ค. - constainsKey(Object key): ์ง์ ํ ํค๊ฐ Map ์์ ์กด์ฌํ๋์ง ํ์ธํ๋ค.
์กด์ฌํ๋ฉด true, ์์ผ๋ฉด false๋ฅผ ๋ฐํํ๋ค. - remove(Object key): ์ง์ ํ ํค๋ฅผ ์ญ์ ํ๊ณ , ๊ทธ ํค์ ํด๋นํ๋ ๊ฐ์ ๋ฐํํ๋ค.
๋ง์ฝ key๊ฐ ์๋ค๋ฉด null์ ๋ฐํํ๋ค. - keySet(): Map์ ์ ์ฅ๋ ๋ชจ๋ ํค๋ค์ ์งํฉ(Set)์ ๋ฐํํ๋ค.
๋ฐ๋ณต๋ฌธ์ผ๋ก ํค๋ค์ ์ํํ ๋ ์ ์ฉํ๋ค. - values(): Map์ ์ ์ฅ๋ ๋ชจ๋ ๊ฐ๋ค์ ์ปฌ๋ ์
(Collection)์ ๋ฐํํ๋ค.
๊ฐ๋ค๋ง ๋ฝ์์ ์ฒ๋ฆฌํ๊ณ ์ถ์ ๋ ์ฌ์ฉํ๋ค. - entrySet(): Map์ ์ ์ฅ๋ ๋ชจ๋ ํค-๊ฐ ์(Map.Entry ๊ฐ์ฒด)์ ๋ฐํํ๋ค.
for-each ๋ฌธ์ผ๋ก ์ํํ๋ฉด์ key, value๋ฅผ ๋์์ ๋ค๋ฃจ๊ณ ์ถ์ ๋ ์์ฃผ ์ฐ์ธ๋ค.
์์ ์ฝ๋
HashMap<Integer,String> map = new HashMap<Integer,String>(){{ // ์ด๊ธฐ๊ฐ ์ง์
put(1,"์ฌ๊ณผ");
put(2,"๋ฐ๋๋");
put(3,"ํฌ๋");
}};
System.out.println(map); // ์ ์ฒด ์ถ๋ ฅ : {1=์ฌ๊ณผ, 2=๋ฐ๋๋, 3=ํฌ๋}
System.out.println(map.get(1)); // key๊ฐ 1์ value ์ป๊ธฐ : ์ฌ๊ณผ
// entrySet() ํ์ฉ
for (Entry<Integer, String> entry : map.entrySet()) {
System.out.println("[Key]:" + entry.getKey() + " [Value]:" + entry.getValue());
}
// [Key]:1 [Value]:์ฌ๊ณผ
// [Key]:2 [Value]:๋ฐ๋๋
// [Key]:3 [Value]:ํฌ๋
// KeySet() ํ์ฉ
for(Integer i : map.keySet()){ // ์ ์ฅ๋ key๊ฐ ํ์ธ
System.out.println("[Key]:" + i + " [Value]:" + map.get(i));
}
// [Key]:1 [Value]:์ฌ๊ณผ
// [Key]:2 [Value]:๋ฐ๋๋
// [Key]:3 [Value]:ํฌ๋
HashMap์ ์ถ๋ ฅํ๋ ๋ฐฉ๋ฒ์๋ ๋ค์ํ ๋ฐฉ๋ฒ์ด ์๋ค.
๊ทธ๋ฅ printํ๊ฒ ๋๋ฉด { }๋ก ๋ฌถ์ด Map์ ์ ์ฒด key๊ฐ, value๊ฐ ์ถ๋ ฅ๋๋ค.
ํน์ key๊ฐ์ value๋ฅผ ๊ฐ์ ธ์ค๊ณ ์ถ๋ค๋ฉด get(key)๋ฅผ ์ฌ์ฉํ๋ฉด ๋๊ณ ์ ์ฒด๋ฅผ ์ถ๋ ฅํ๋ ค๋ฉด entrySet()์ด๋ keySet() ๋ฉ์๋๋ฅผ ํ์ฉํ์ฌ Map์ ๊ฐ์ฒด๋ฅผ ๋ฐํ๋ฐ์ ํ ์ถ๋ ฅํ๋ฉด ๋๋ค.
entrySet()์ key์ value ๋ชจ๋๊ฐ ํ์ํ ๊ฒฝ์ฐ ์ฌ์ฉํ๋ฉฐ keySet()์ key ๊ฐ๋ง ํ์ํ ๊ฒฝ์ฐ ์ฌ์ฉํ๋๋ฐ
key๊ฐ๋ง ๋ฐ์์ get(key)๋ฅผ ํ์ฉํ์ฌ value๋ ์ถ๋ ฅํ ์๋ ์๊ธฐ์ ์ด๋ค ๋ฉ์๋๋ฅผ ์ ํํ๋ ์ง ๊ฐ์ ํฐ ์๊ด์ด ์์ด ๋๋ถ๋ถ ์ฝ๋๊ฐ ๊ฐ๋จํ keySet()์ ํ์ฉํ๋ค.
ํ์ง๋ง key๊ฐ์ ์ด์ฉํด์ value๋ฅผ ์ฐพ๋ ๊ณผ์ ์์ ์๊ฐ์ด ๋ง์ด ์๋ชจ๋๋ฏ๋ก ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์์ผ ํ๋ค๋ฉด entrySet()์ด ์ข๋ค.
๐ HashMap ์ ๋ ฌ์?
HashMap ์์ฒด๋ ์์๋ฅผ ๋ณด์ฅํ์ง ์๋๋ค.
์ ๋ ฌ์ด ํ์ํ ๋ entrySet()์ ๊บผ๋ด์ ๋ฆฌ์คํธ๋ก ๋ฐ๊พผ ๋ค Collections.sort() ๋๋ stream().sorted()๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
List<Map.Entry<Integer, Integer>> entryList = new ArrayList<>(map.entrySet());
entryList.sort((e1, e2) -> e2.getValue() - e1.getValue()); // value ๊ธฐ์ค ๋ด๋ฆผ์ฐจ์
๐ HashMap์ ์ด๋์ ์ฐ์ผ๊น?
- ๐ ๋น๋ ์ ์ธ๊ธฐ (ex. ๋ฑ์ฅ ํ์)
- ๐งญ ๋น ๋ฅธ ๊ฒ์ (ex. ํน์ ๊ฐ ์กด์ฌ ์ฌ๋ถ ํ์ธ)
- ๐งฉ ๊ทธ๋ฃนํ (ex. ๊ฐ์ ์กฐ๊ฑด๋ผ๋ฆฌ ๋ฌถ๊ธฐ)
"์ด๋ค ๋ฐ์ดํฐ๊ฐ ๋ช ๊ฐ ์๋์ง ์ธ๊ณ , ๊ฐ์๊ฐ ๋ง์ ์์ผ๋ก ์ ๋ ฌํด ํ์ฉํ๋ ๋ฌธ์ "์ ๋ฑ์ด๋ค!
๐งฑ ์ ๋ฆฌ
- HashMap์ ํค-๊ฐ ์ ์ ์ฅ์ ์ต์ ํ๋ ์๋ฃ๊ตฌ์กฐ
- ๋น ๋ฅธ ๊ฒ์๊ณผ ๋น๋ ์ ๊ณ์ฐ์ ๋งค์ฐ ์ ์ฉํจ
- ์ ๋ ฌ ์์๋ entrySet์ ์ ๋ ฌํด์ผ ํจ
- ์ฝ๋ฉํ ์คํธ์์ ์์ฃผ ๋ฑ์ฅํ๋ ํ์ ์๋ฃ๊ตฌ์กฐ ์ค ํ๋
๐ References
https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html
HashMap (Java Platform SE 8 )
If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null. If the function returns null no mapping is recorded. If the function
docs.oracle.com
https://coding-factory.tistory.com/556
[Java] ์๋ฐ HashMap ์ฌ์ฉ๋ฒ & ์์ ์ด์ ๋ฆฌ
HashMap ์ด๋? HashMap์ Map ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๋ํ์ ์ธ Map ์ปฌ๋ ์ ์ ๋๋ค. Map ์ธํฐํ์ด์ค๋ฅผ ์์ํ๊ณ ์๊ธฐ์ Map์ ์ฑ์ง์ ๊ทธ๋๋ก ๊ฐ์ง๊ณ ์์ต๋๋ค. Map์ ํค์ ๊ฐ์ผ๋ก ๊ตฌ์ฑ๋ Entry๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋
coding-factory.tistory.com
'๐ Java > ๐พ ์๋ฃ๊ตฌ์กฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ Java ] Stack? ๊ทธ๋ฅ ์๊ธฐ๋ง ํ๋ ์ค ์์์ง,, (0) | 2025.03.28 |
---|