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);

๊ฒฐ๊ณผ:

{์•ค์„œ๋‹ˆ=5, ๋‹‰=4, ์˜ฌ๋ฆฌ๋ฒ„=5, ๋ก์‹œ=5, ์‚ฌ๋ผ=5, ์ œํ”„=4}

ํ‚ค-๊ฐ’ ์Œ์„ ์ถ”๊ฐ€ํ•  ๋•Œ ํ‚ค๊ฐ€ ์ด๋ฏธ ์ปฌ๋ ‰์…˜์— ์žˆ์œผ๋ฉด ์ด์ „ ๊ฐ’์ด ์ƒˆ ๊ฐ’์œผ๋กœ ๋Œ€์ฒด๋ฉ๋‹ˆ๋‹ค. ์ด ๋™์ž‘์€ ("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);

๊ฒฐ๊ณผ ์‹œํ€€์Šค๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

lengthComparedMap: {Jan=4, Jeff=4, Roxy=4, Oliver=5}

์ด ๋™์ž‘์€ ์ธ๋ฑ์Šค๊ฐ€ ์ˆซ์ž ๋Œ€์‹  ๋‹จ์–ด( String ) ์ธ ์ •๋ ฌ๋œ ๋ฐฐ์—ด ๋˜๋Š” ๋ชฉ๋ก๊ณผ ๊ฐ™์€ TreeMap ์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค.

๊ฑฐ์˜ ๋ชจ๋“  ํ˜•์‹์ด KeyType ๋˜๋Š” ValueType์ด ๋  ์ˆ˜ ์žˆ๋‹ค๋Š” ์ ์— ์œ ์˜ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. KeyType์— ๋Œ€ํ•œ ์•ฝ๊ฐ„์˜ ์ถ”๊ฐ€ ์š”๊ตฌ ์‚ฌํ•ญ์ด ์žˆ์œผ๋ฉฐ ์ปฌ๋ ‰์…˜์„ ๋” ์ž์„ธํžˆ ์—ฐ๊ตฌํ•  ๋•Œ ์ด์— ๋Œ€ํ•ด ๋ฐฐ์šฐ๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

TreeMap ํด๋ž˜์Šค์˜ SortedMap ๋ฉ”์„œ๋“œ

  1. ์ฒซ ๋ฒˆ์งธ ํ•™์ƒ์˜ ํ‚ค๋ฅผ ๊ฐ€์ ธ์™€์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ firstKey () ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

    
    String firstKey = map.firstKey();
    	System.out.println("First key โ†’ " + firstKey);
    

    ๊ฒฐ๊ณผ: ์ฒซ ๋ฒˆ์งธ ํ‚ค โ†’ Anthony

  2. ๋งˆ์ง€๋ง‰ ํ•™์ƒ์˜ ํ‚ค๋ฅผ ๊ฐ€์ ธ์™€์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ lastKey () ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

    
    String lastKey = map.lastKey();
    System.out.println("Last key โ†’ " + lastKey);
    

    ๊ฒฐ๊ณผ: ๋งˆ์ง€๋ง‰ ํ‚ค โ†’ Jeff

  3. ํ‚ค " Sara " ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๊ฐœ์ฒด ๋’ค์— ์˜ค๋Š” ๋ชจ๋“  ๊ฐœ์ฒด๋ฅผ ๊ฐ€์ ธ์˜ต๋‹ˆ๋‹ค .

    
    Map<String, Integer> tailMap = map.tailMap("Sara");
             	System.out.println("tailMap: " + tailMap);
    

    ๊ฒฐ๊ณผ: tailMap: {Sara=5, Jeff=4}

  4. ํ‚ค๊ฐ€ " Nick " ์ธ ๊ฐœ์ฒด ์•ž์— ์˜ค๋Š” ๋ชจ๋“  ๊ฐœ์ฒด ๊ฐ€์ ธ์˜ค๊ธฐ :

    
    System.out.println("headMap: " + headMap);
     Map<String, Integer> headMap = map.headMap("Nick");
    

    ๊ฒฐ๊ณผ: headMap: {Anthony=5}

  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์€ ์ €์žฅ ์ˆœ์„œ๋‚˜ ๋งต์—์„œ ์š”์†Œ๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ์ˆœ์„œ๋ฅผ ๋ณด์žฅํ•˜์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.