'์ฝ๋ฉ์ธํฐ๋ทฐ'์ '์ ํ๋ธ'๋ฅผ ์ฐธ๊ณ ํ์ฌ ์์ฑํ์์ต๋๋ค.
HashMap, LinkedHashMap, TreeMap, Hashtable ๋ค ๊ฐ์ง ๋ชจ๋ ํค(key)์์ ๊ฐ(value)์ผ๋ก์ ๋์ ๊ด๊ณ๊ฐ ์๊ณ ํค๋ฅผ ๊ธฐ์ค์ผ๋ก ์ํํ ์ ์๋ค. ์ด ํด๋์ค๋ค์ ๊ฐ์ฅ ํฐ ์ฐจ์ด์ ์ ์๊ฐ ๋ณต์ก๋์ ํค๊ฐ ๋์ด๋ ์์์ ์๋ค.
HashMap
- ๊ฒ์๊ณผ ์ฝ์ ์ O(1) ์๊ฐ์ด ์์๋๋ค.
- ํค์ ์์๋ ๋ฌด์์๋ก ์์ฌ ์๋ค.
- ๊ตฌํ์ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ์ด๋ฃจ์ด์ง ๋ฐฐ์ด๋ก ๋์ด ์๋ค.
- null key์ null value๋ฅผ ๋ชจ๋ ํ์ฉ
LinkedHashMap
- ๊ฒ์๊ณผ ์ฝ์ ์ O(1) ์๊ฐ์ด ์์๋๋ค.
- ํค์ ์์๋ ์ฝ์ ํ ์์๋๋ก ์ ๋ ฌ๋์ด ์๋ค.
- ๊ตฌํ์ ์๋ฐฉํฅ ์ฐ๊ฒฐ ๋ฒํท(double-linked bucket)์ผ๋ก ๊ตฌํ๋์ด ์๋ค.
TreeMap
- ๊ฒ์๊ณผ ์ฝ์ ์ O(log N) ์๊ฐ์ด ์์๋๋ค.
- ํค์ ์์๋ ์ ๋ ฌ๋์ด ์๋ค.
- ์ฆ, ํค๋ ๋ฐ๋์ Comparable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ณ ์์ด์ผ ํ๋ค.
- ๊ตฌํ์ ๋ ๋-๋ธ๋ ํธ๋ฆฌ๋ก ๊ตฌํ๋์ด ์๋ค.
Hashtable
- ๊ฒ์๊ณผ ์ฝ์ ์ O(1) ์๊ฐ์ด ์์๋๋ค.
- ํค์ ์์๋ ๋ฌด์์๋ก ์์ฌ ์๋ค.
- ๊ตฌํ์ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ์ด๋ฃจ์ด์ง ๋ฐฐ์ด๋ก ๋์ด ์๋ค.
์ฌ๊ธฐ๊น์ง HashMap๊ณผ ๋์ผ
- null key์ null value ๋ชจ๋ ๋ถํ
- ๋๊ธฐํ๋ฅผ ์ง์ํ๋ค. (thread safe)
๋ฐ๋ผ์ Hashtable์ ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์ ๋์๊ฐ๋ฅํ๋ฉฐ, ๋๊ธฐํ๋ฅผ ์ง์ํ๊ธฐ ๋๋ฌธ์ HashMap๋ณด๋ค๋ ๋๋ฆฌ๋ค.
์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
package Study;
import java.util.*;
public class Learn_Map {
public static void main(String[] args) {
HashMap<String, String> dictionary = new HashMap<String, String>();
// Hashtable<String, String> dictionary = new Hashtable<>();
// LinkedHashMap<String, String> dictionary = new LinkedHashMap<String, String>();
// TreeMap<String, String> dictionary = new TreeMap<String, String>();
dictionary.put("Brave", "ready to face and endure danger or pain; showing courage.");
dictionary.put("Brilliant", "exceptionally clever or talented.");
dictionary.put("Joy", "a feeling of great pleasure and happiness.");
dictionary.put("Confidence", "the state of feeling certain about the truth of something");
dictionary.put("Brilliant", "XXXXX"); // map cannot be used to store duplicates -> overriding (similar to Set)
// for(String word: dictionary.keySet()){
// System.out.println(word); // print Key
// System.out.println(dictionary.get(word)); // print Value
// }
for(Map.Entry<String, String> entry: dictionary.entrySet()){
System.out.println(entry.getKey()); // print Key
System.out.println(entry.getValue()); // print Value
}
}
}
|
cs |
์คํ๊ฒฐ๊ณผ
keySet์ ๊ฐ์ ธ์์ key์ value๋ฅผ ์ถ๋ ฅํ ์๋ ์์ผ๋ ์ผ๋ฐ์ ์ผ๋ก ๋ ๋ค ์ถ๋ ฅ์ด ํ์ํ ๊ฒฝ์ฐ entrySet์ ๊ฐ์ ธ์์ ์ถ๋ ฅํ๋๊ฒ์ด ์ข๋ค๊ณ ํ๋ค.
HashMap๊ณผ Hashtable์ ๋ฌด์์๋ก ์ถ๋ ฅ์ด ๋๋ฉฐ, LinkedHashMap์ ์ฝ์ ํ ์์๋๋ก ์ถ๋ ฅ๋๋ฉฐ TreeMap์ ์ ๋ ฌ๋์ด ์ถ๋ ฅ๋๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
ํ์ฉ
์ด๋ฆ๊ณผ Person์ด๋ผ๋ ๊ฐ์ฒด ์ฌ์ด์ ๋์ ๊ด๊ณ๋ฅผ ๋ง๋ ๋ค๊ณ ํด ๋ณด์. ๊ทธ๋ฆฌ๊ณ ์ฃผ๊ธฐ์ ์ผ๋ก ์ด๋ฆ์์ผ๋ก ์ฌ๋์ ์ถ๋ ฅํ๊ณ ์ถ๋ค๋ฉด TreeMap์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
๋ํ TreeMap์ ์ด๋ฆ์ด ์ฃผ์ด์ก์ ๋ ๊ทธ๋ค์ 10๋ช ์ ์ฌ๋๋ ์ถ๋ ฅํ ์ ์๋ค. ์ด๋ ๋ง์ ํ๋ก๊ทธ๋จ์์ ์ฌ์ฉํ๋ 'More'๊ธฐ๋ฅ์ ๊ตฌํํ ๋ ์ ์ฉํ ์ ์๋ค.
LinkedHashMap์ ์ฝ์ ํ ์์๋๋ก ํค๋ฅผ ์ ๋ ฌํ๊ณ ์ถ์ ๋ ์ ์ฉํ๋ค. ์บ์๋ฅผ ๊ตฌํํ ๋ ๊ฐ์ฅ ์ค๋๋ ์์ดํ ์ ๋จผ์ ์ญ์ ํ๊ณ ์ถ์ ๊ฒฝ์ฐ์ ์ ์ฉํ ์ ์๋ค.
๊ฒฐ๋ก
์ผ๋ฐ์ ์ผ๋ก ๋ณ๋ค๋ฅธ ์ด์ ๊ฐ ์์ผ๋ฉด HashMap์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค. ์ผ๋ฐ์ ์ผ๋ก ๋น ๋ฅด๊ณ ์ค๋ฒํค๋๊ฐ ์ ๊ธฐ ๋๋ฌธ์ด๋ค.
ํน๋ณํ ์ํฉ ์ฆ, ์ฝ์ ํ ์์๋๋ก ํค ์ ๋ณด๋ฅผ ์ป๊ณ ์ถ๋ค๋ฉด LinkedHashMap์ ์ฌ์ฉํ๋ฉด ๋๊ณ , ์ ๋ ฌ๋ ์์๋๋ก ํค ์ ๋ณด๋ฅผ ์ป๊ณ ์ถ๋ค๋ฉด TreeMap, ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ํ๋ฉด์ ์์์ ๋๊ธฐํ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ ์ํฉ์ด๋ผ๋ฉด Hashtable์ ์ฌ์ฉํ๋ฉด ๋๋ค.
'๐ > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์๋ฐ ๊ฐ์ ๋จธ์ (Java Virtual Machine) (0) | 2021.07.28 |
---|---|
[Java] Primitive type vs Reference type (0) | 2021.04.18 |
[Java] ==, equals, instanceof (0) | 2020.09.09 |
[Java] int ์ Integer ์ฐจ์ด์ (0) | 2020.09.08 |
[Java] finalize ๋ฉ์๋ (0) | 2020.09.08 |
๋๊ธ