SortedMap
์ด ํ์ต์์๋ SortedMap ์ธํฐํ์ด์ค๋ฅผ ํ์ตํฉ๋๋ค . ์ฐ๋ฆฌ๋ ์ด ์ธํฐํ์ด์ค ์ ๋ํ๋๋ ์๋ก์ด ๋ฉ์๋์ SortedMap ์ ํ ๊ตฌํ์ธ TreeMap ์ ๊ธฐ๋ฅ, ๊ตฌํ ๊ฐ์ ์ฐจ์ด์ , HashMap ๊ณผ ๋น๊ตํ ์ฅ์ ์ ์ดํด๋ณผ ๊ฒ์ ๋๋ค .
์ง๋์ ๊ณ์ธต ๊ตฌ์กฐ๊ฐ ์ด๋ป๊ฒ ์๊ฒผ๋์ง ๋ด ์๋ค. SortedMap ์ธํฐํ์ด์ค์ TreeMap ๊ตฌํ ์ ํน๋ณํ ์ฃผ์๋ฅผ ๊ธฐ์ธ์ด์ญ์์ค . ์ค๋ ์ฐ๋ฆฌ์ ์ด์ ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
SortedMap ์ธํฐํ์ด์ค ๋ Map ์ธํฐํ์ด์ค๋ฅผ ํ์ฅํฉ๋๋ค . ๋ ๊ฐ์ง ๋ชจ๋ ์ ๋ ฌ๋ ๊ฐ์ ์ ์ฅํ๊ณ ์ฌ์ฉํ๋ ์ ์ฌํ ๊ธฐ๋ฅ์ ์ค๋ช ํ๊ธฐ ๋๋ฌธ์ ์ฌ๋ฌ ๊ฐ์ง ๋ฉด์์ SortedSet ( Set ์ ํ์ฅํจ ) ์ ์ ์ฌํฉ๋๋ค .
SortedSet์ <TValue>์ ํจ๊ป ์๋ํ๊ณ ์ ์ฅํ์ง๋ง SortedMap์<TKey, TValue>์์ ์ ์ฅํฉ๋๋ค. ๋ชจ๋ ์์๋ฅผ โโํค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ์ฅํ๋ ๋งต์ ๋๋ค.
SortedMap ์ธํฐํ์ด์ค ๋ Map ์ ํ์ฅํฉ๋๋ค . ๋ค์ ๋ฉ์๋๋ฅผ ์ถ๊ฐํฉ๋๋ค.
๋ฐฉ๋ฒ | ์ค๋ช |
---|---|
Tํค ์ฒซํค() | ์ง๋์ ์ฒซ ๋ฒ์งธ ์์์ ํค๋ฅผ ๋ฐํํฉ๋๋ค. |
Tํค ๋ง์ง๋ง ํค() | ๋งต์ ๋ง์ง๋ง ์์์ ํค๋ฅผ ๋ฐํํฉ๋๋ค. |
SortedMap<TKey, TValue> headMap(TKey ๋) | ํค ๋์ด ์๋ ์์๋ฅผ ํฌํจํ์ฌ ์๋ SortedMap ์ ๋ชจ๋ ์์๋ฅผ โโํฌํจํ๋ SortedMap์ ๋ฐํํฉ๋๋ค. |
SortedMap<TKey, Tvalue> tailMap(K ์์) | start ํค๊ฐ ์๋ ์์์์ ์์ํ์ฌ ์๋ SortedMap ์ ๋ชจ๋ ์์๋ฅผ โโํฌํจํ๋ SortedMap ์ ๋ฐํํฉ๋๋ค (ํฌํจ). |
SortedMap<TKey, TValue> subMap(TKey ์์, TKey ๋) | ์์ ํค๊ฐ ์๋ ์์์์ ํค ๋์ด ์๋ ์์๊น์ง ์๋ SortedMap ์ ๋ชจ๋ ์์๋ฅผ โโํฌํจํ๋ SortedMap ์ ๋ฐํํฉ๋๋ค (end ์ ์ธ ) . |
TreeMap ํด๋์ค
TreeMap ํด๋์ค ๋ SortedMap ์ธํฐํ์ด์ค ์ ๊ตฌํ์ ๋๋ค . ์ฆ, TreeMap์ SortedMap ์ ์ํด ์ถ๊ฐ๋ ๋ชจ๋ ๋ฉ์๋ ์ Map ์ธํฐํ์ด์ค์ ํ์ค ๋ฉ์๋๋ฅผ ๊ตฌํํฉ๋๋ค.
๋ค์๊ณผ ๊ฐ์ ์์ฑ์๋ฅผ ์ฌ์ฉํ์ฌ TreeMap ๊ฐ์ฒด๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค .
-
TreeMap() : ํธ๋ฆฌ๋ก ๊ตฌํ๋ ๋น ๋งต์ ์์ฑํฉ๋๋ค.
-
TreeMap(Map<? extends TKey, ? extends TValue> map) : ํธ๋ฆฌ๋ฅผ ์์ฑํ๊ณ ์ ๋ ฅ ๋งต์ ๋ชจ๋ ์์๋ฅผ โโ์ถ๊ฐํฉ๋๋ค.
-
TreeMap(SortedMap<TKey, ? extends TValue> smap) : ํธ๋ฆฌ๋ฅผ ์์ฑํ๊ณ ์ ๋ ฅ ์ ๋ ฌ ๋งต์์ ๋ชจ๋ ์์๋ฅผ โโ์ถ๊ฐํฉ๋๋ค.
-
TreeMap(Comparator<? super TKey> comparator) : ๋น ํธ๋ฆฌ๋ฅผ ์์ฑํฉ๋๋ค. ๋น๊ต๊ธฐ๋ ์ดํ์ ์ถ๊ฐ๋๋ ๋ชจ๋ ์์๋ฅผ โโ์ ๋ ฌํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
์ฌ๊ธฐ์ TKey ๋ ์ ์ฅ๋ ์์ ํค ์ ํ์ด๊ณ TValue ๋ TreeMap ์ ์ ์ฅ๋ ์์ ๊ฐ ์ ํ์ ๋๋ค .
๋น๊ต๊ธฐ๋ SortedMap / TreeMap ์์ ๋งค์ฐ ์ค์ํฉ๋๋ค. ์ง๋๋ฅผ ์ ๋ ฌํ๊ฑฐ๋ ์ ๋ ฌํ๊ธฐ ์ํ ๊ท์น์ ์ค์ ํฉ๋๋ค. ๋น๊ต๊ธฐ๋ฅผ ์ ๊ณตํ์ง ์์ผ๋ฉด SortedMap ์ ๋ง๋ค ๋ ํค์ ์์ฐ์ค๋ฌ์ด ์์๊ฐ ์ฌ์ฉ ๋ฉ๋๋ค .
TreeMap์ ์์ ์ถ๊ฐ
์์๋ put() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์์ผ๋ก ๋งต์ ์ถ๊ฐ๋ฉ๋๋ค . ํค๋ ์ฒซ ๋ฒ์งธ ์ธ์๋ก ์ ๋ฌ๋๊ณ ๊ฐ์ ๋ ๋ฒ์งธ๋ก ์ ๋ฌ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด ํ์ ๋ฐ ์ฑ์ ๋ชฉ๋ก์ ์์ฑํ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค.
SortedMap<String, Integer> map =new TreeMap <String,Integer>();
map.put("Anthony", 5);
map.put("Sara", 5);
map.put("Roxy", 5);
map.put("Jeff", 4);
map.put("Nick", 4);
map.put("Oliver", 3);
map.put("Oliver", 5);
System.out.println(map);
๊ฒฐ๊ณผ:
ํค-๊ฐ ์์ ์ถ๊ฐํ ๋ ํค๊ฐ ์ด๋ฏธ ์ปฌ๋ ์ ์ ์์ผ๋ฉด ์ด์ ๊ฐ์ด ์ ๊ฐ์ผ๋ก ๋์ฒด๋ฉ๋๋ค. ์ด ๋์์ ("Oliver", 3) ๋ฐ ("Oliver", 5) ์ ๊ฐ์ ๋์ผํ ํค๋ฅผ ๊ฐ์ง ๋ ์์ ์์์ ์ค๋ช ๋ฉ๋๋ค .
์ฐ๋ฆฌ๊ฐ ๋ง๋ ๋น๊ต๊ธฐ ๊ฐ ์๋ ์๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค . ํค ๋ฌธ์์ด์ ๊ธธ์ด๋ก ์ ๋ ฌ๋ ์์๋ฅผ ์ ์ฅํ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ํค ๊ธธ์ด๊ฐ ๊ฐ์ผ๋ฉด ์ํ๋ฒณ์์ผ๋ก ์ ๋ ฌํฉ๋๋ค(๋ฌธ์์ด์ ์์ฐ์ค๋ฌ์ด ์์).
class LengthComparator implements Comparator<String> {
public int compare(String o1, String o2) {
Integer lenghComparedResult = Integer.compare(o1.length(), o2.length());
return lenghComparedResult != 0 ? lenghComparedResult : o1.compareTo(o2);
}
}
SortedMap<String, Integer> lengthComparedMap = new TreeMap<String, Integer>(new LengthComparator());
lengthComparedMap.put("Jeff", 4);
lengthComparedMap.put("Oliver", 5);
lengthComparedMap.put("Roxy", 4);
lengthComaredMap.put("Jan", 4);
๊ฒฐ๊ณผ ์ํ์ค๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ด ๋์์ ์ธ๋ฑ์ค๊ฐ ์ซ์ ๋์ ๋จ์ด( String ) ์ธ ์ ๋ ฌ๋ ๋ฐฐ์ด ๋๋ ๋ชฉ๋ก๊ณผ ๊ฐ์ TreeMap ์ ๋ง๋ญ๋๋ค.
๊ฑฐ์ ๋ชจ๋ ํ์์ด KeyType ๋๋ ValueType์ด ๋ ์ ์๋ค๋ ์ ์ ์ ์ํด์ผ ํฉ๋๋ค. KeyType์ ๋ํ ์ฝ๊ฐ์ ์ถ๊ฐ ์๊ตฌ ์ฌํญ์ด ์์ผ๋ฉฐ ์ปฌ๋ ์ ์ ๋ ์์ธํ ์ฐ๊ตฌํ ๋ ์ด์ ๋ํด ๋ฐฐ์ฐ๊ฒ ๋ฉ๋๋ค. |
TreeMap ํด๋์ค์ SortedMap ๋ฉ์๋
-
์ฒซ ๋ฒ์งธ ํ์์ ํค๋ฅผ ๊ฐ์ ธ์์ผ ํ๋ ๊ฒฝ์ฐ firstKey () ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
String firstKey = map.firstKey(); System.out.println("First key โ " + firstKey);
๊ฒฐ๊ณผ: ์ฒซ ๋ฒ์งธ ํค โ Anthony
-
๋ง์ง๋ง ํ์์ ํค๋ฅผ ๊ฐ์ ธ์์ผ ํ๋ ๊ฒฝ์ฐ lastKey () ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
String lastKey = map.lastKey(); System.out.println("Last key โ " + lastKey);
๊ฒฐ๊ณผ: ๋ง์ง๋ง ํค โ Jeff
-
ํค " Sara " ๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ฒด ๋ค์ ์ค๋ ๋ชจ๋ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ต๋๋ค .
Map<String, Integer> tailMap = map.tailMap("Sara"); System.out.println("tailMap: " + tailMap);
๊ฒฐ๊ณผ: tailMap: {Sara=5, Jeff=4}
-
ํค๊ฐ " Nick " ์ธ ๊ฐ์ฒด ์์ ์ค๋ ๋ชจ๋ ๊ฐ์ฒด ๊ฐ์ ธ์ค๊ธฐ :
System.out.println("headMap: " + headMap); Map<String, Integer> headMap = map.headMap("Nick");
๊ฒฐ๊ณผ: headMap: {Anthony=5}
-
" Oliver " ํค๊ฐ ์๋ ๊ฐ์ฒด ๋ค์ ์ค๋ ๋ชจ๋ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ค๊ณ " Sara " ํค๊ฐ ์๋ ๊ฐ์ฒด ์์ ์ค๋ ๋ชจ๋ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ธ์ต๋๋ค .
Map<String, Integer> subMap = map.subMap("Oliver", "Sara"); System.out.println("subMap: " + subMap);
๊ฒฐ๊ณผ: ํ์ ๋งต: {Oliver=5, Roxy=5}
HashMap๊ณผ SortedMap/TreeMap์ ๋น๊ต
์์๊ฐ ์ ๋ ฌ๋๊ณ ์ ์ฅ๋๋ ๋ฐฉ๋ฒ์ ๋ํด ์ด์ผ๊ธฐํด ๋ณด๊ฒ ์ต๋๋ค.
-
HashMap์ ๋ฐ๋ณตํ ๋ ์์๋ฅผ ๋ณด์ฅํ์ง ์๊ธฐ ๋๋ฌธ์ ์ ์์๊ฐ ์ถ๊ฐ๋๋ฉด ์์๊ฐ ์์ ํ ๋ฐ๋ ์ ์์ต๋๋ค.
-
TreeMap ์์ ์์๋ compareTo() ๋ฉ์๋(๋๋ ์ฐ๋ฆฌ๊ฐ ์ ๊ณตํ๋ Comparator )์ ๋ฐ๋ฅธ ํค์ "์์ฐ ์์"๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค. ๋ํ TreeMap์ด ์ด ์ ๋ ฌ ์์์ ์์กดํ๋ ๋ฉ์๋๋ฅผ ํฌํจํ๋ SortedMap ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ค๋ ์ฌ์ค์ ์์ง ๋ง์ญ์์ค .
์ด์ ์ฑ๋ฅ๊ณผ ์๋๋ฅผ ๊ณ ๋ คํฉ๋๋ค.
-
HashMap ์ ํด์ฑ ํค๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ๋งต์ ๋๋ค. O(1), ์์ ์๊ฐ์ ์์๋ฅผ ์ฝ์ ํ๊ณ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค์ด๋ฅผ ์ง์ํ๋ ค๋ฉด ํค๊ฐhashCode()๋ฐequals() ๋ฅผ.
-
TreeMap ์ ํธ๋ฆฌ ๊ธฐ๋ฐ ๋งต์ ๋๋ค. ์ฝ์ ๋ฐ ๊ฐ์ ธ์ค๊ธฐ ์์ ์๋ ๋ก๊ทธ ์๊ฐ, ์ฆO(log n)์ด๋ ๋งต์ ์์ ์์ ๋ฐ๋ผ ๋ค๋ฆ ๋๋ค. ์ด๋ ์์๊ฐ ํค ๋๋ ์ธ๋ถ ๋น๊ต๊ธฐ์ ์ํด ์ ๊ณต๋๋ ์ผ์ข ์ ๋น๊ต ๋ฉ์ปค๋์ฆ์ ๊ฐ๊ธฐ ์ํด ํ์ํฉ๋๋ค. ์ด ๋ฉ์ปค๋์ฆ์ ๋ฐ๋ณต ์์๋ฅผ ๊ฒฐ์ ํฉ๋๋ค.
์ด๋ฌํ ์์๋ ์ด๋ค ์ปฌ๋ ์ ์ ์ธ์ ์ฌ์ฉํ ์ง ๊ฒฐ์ ํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค.
ํน์ ์์๋ก ๊ฐ์ ์ ์ฅํด์ผ ํ๋ ๊ฒฝ์ฐ ์ ํ์ ๋ช ๋ฐฑํฉ๋๋ค. SortedMap ์ด ํ์ ํฉ๋๋ค . HashMap ๋ณด๋ค ์ฝ๊ฐ ๋๋ฆฌ์ง๋ง ์ค์ํ ์์ ์ ์ํํฉ๋๋ค.
์์์ ์ธ๊ธํ๋ฏ์ด SortedMap์ ๊ฐ์ด ์ถ๊ฐ๋ ์์ ์ ๊ด๊ณ์์ด ๋งต์ ์ฒซ ๋ฒ์งธ(๋๋ ๋ง์ง๋ง) ํค, ๊ฐ ๋๋ ํค-๊ฐ ์์ ์ ๊ณตํ ์ ์์ต๋๋ค. HashMap ๊ตฌํ ์ ์ด๊ฒ์ ํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด ํค(ํ์ ์ด๋ฆ)์ ๊ฐ(์ฑ์ )์ด ์๋ ์ง๋๋ฅผ ์๊ฐํด ๋ณด์ญ์์ค. ๋ชฉ๋ก์ ์ํ๋ฒณ ์ญ์์ผ๋ก ์์ ํ๊ณ ์ถ๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค.
1.
SortedMap<String, Integer> sorted = new TreeMap<String,Integer>(Comparator.reverseOrder());
sorted.put("Anthony", 5);
sorted.put("Sara", 5);
sorted.put("Jeff", 4);
String firstKeyFromSortedMapVariant = sorted.firstKey();
Integer markFromSortedMap = sorted.get(firstKeyFromSortedMapVariant);
System.out.println(firstKeyFromSortedMapVariant + " - " + markFromSortedMap);
2.
HashMap<String, Integer> hash = new HashMap<String,Integer>();
hash.put("Anthony", 5);
hash.put("Sara", 5);
hash.put("Jeff", 4);
SortedSet<String> keySetOfHashMap = new TreeSet<String>(Comparator.reverseOrder());
// Or sort manually, storing elements in an array or list (preserving the insertion order)
keySetOfHashMap.addAll(hash.keySet());
String firstKeyFromHashMapVariant = keySetOfHashMap.first();
Integer markFromHashMap = hash.get(firstKeyFromHashMapVariant);
System.out.println(firstKeyFromHashMapVariant + " - " + markFromHashMap);
์์ ๋ HashMap ์ ์ฌ์ฉํ๋ฉด ์์ ์ด ๋ ๋ณต์กํด์ง์ ๋ณด์ฌ์ค๋๋ค. HashMap์ ์ ์ฅ ์์๋ ๋งต์์ ์์๋ฅผ ๊ฐ์ ธ์ค๋ ์์๋ฅผ ๋ณด์ฅํ์ง ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
GO TO FULL VERSION