CodeGym/Java Blog/๋ฌด์ž‘์œ„์˜/HashMap์—์„œ ๊ธฐ์กด ํ‚ค ๊ฐ’์„ ์—…๋ฐ์ดํŠธํ•˜๋Š” ๋ฐฉ๋ฒ•
John Squirrels
๋ ˆ๋ฒจ 41
San Francisco

HashMap์—์„œ ๊ธฐ์กด ํ‚ค ๊ฐ’์„ ์—…๋ฐ์ดํŠธํ•˜๋Š” ๋ฐฉ๋ฒ•

๋ฌด์ž‘์œ„์˜ ๊ทธ๋ฃน์— ๊ฒŒ์‹œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค
ํšŒ์›
HashMap ๋˜๋Š” ๋‹ค๋ฅธ Map ์—๋Š” ํ•ญ์ƒ ํ‚ค์™€ ๊ฐ’์ด ์žˆ๋‹ค๋Š” ๊ฒƒ์„ ์•Œ๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค . ํ‚ค๋ฅผ ํ†ตํ•ด ๊ฐ’์— ์•ก์„ธ์Šคํ•  ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ํ‚ค๋ฅผ ํ‚ค๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ํ‚ค๋Š” ๊ณ ์œ ํ•˜์ง€๋งŒ ๊ฐ’์€ ๊ณ ์œ ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ๊ฐ’์ด ์ค‘๋ณต๋  ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ๊ฐ’์œผ๋กœ ํ‚ค๋ฅผ ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ์ด ๊ธฐ์‚ฌ์—์„œ๋Š” Java์—์„œ HashMap ์˜ ๊ธฐ์กด ํ‚ค ๊ฐ’์„ ์—…๋ฐ์ดํŠธํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์•Œ์•„๋ด…๋‹ˆ๋‹ค . Java ๊ตฌ๋ฌธ์„ ๊ธฐ์–ตํ•ฉ์‹œ๋‹ค. Java์˜ HashMap์€ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์„ ์–ธ๋ฉ๋‹ˆ๋‹ค.
HashMap<Key, Value> name
์˜ˆ๋ฅผ ๋“ค์–ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ์šฐ๋ฆฌ๋Š” 4๋ช…์˜ ์นœ๊ตฌ๊ฐ€ ์žˆ๊ณ  ํŠนํžˆ ๊ทธ๋“ค์„ ์œ„ํ•ด ๊ทธ๋“ค์˜ ์ด๋ฆ„์œผ๋กœ HashMap์„ ๋งŒ๋“ค๊ณ  ์ฑ„์› ์Šต๋‹ˆ๋‹ค. ๊ทธ๋“ค์˜ ํ‚ค๋Š” ์ •์ˆ˜์ž…๋‹ˆ๋‹ค.
Map<Integer, String> names = new HashMap<Integer, String>();
       names.put(1, "Stan");
       names.put(2, "Kyle");
       names.put(3, "Kenny");
       names.put(4, "Cartman");
์ฐธ๊ณ : ๋‹ค์–‘ํ•œ ๋ฐฉ๋ฒ•์œผ๋กœ ์ง€๋„๋ฅผ ๋งŒ๋“ค๊ณ  ์ฑ„์šธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค . ์˜ˆ๋ฅผ ๋“ค์–ด ์ดˆ๊ธฐํ™” ๋ธ”๋ก์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์žˆ์–ด:
Map<Integer, String> names = new HashMap<Integer, String>() {
           {
               put(1, "Stan");
               put(2, "Kyle");
               put(3, "Kenny");
               put(4, "Cartman");
           }
       };
๋˜๋Š” ๋‹ค๋ฅธ ๋งต ์ธ์ˆ˜์™€ ํ•จ๊ป˜ ๋ฉ”์„œ๋“œ ๋ฐ HashMap ์ƒ์„ฑ์ž๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค . ์ด ๋ฐฉ๋ฒ•์€ ๋ฒ„์ „ 9 ์ด์ƒ์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
Map<Integer, String> names = new HashMap<>(Map.of(1, "Stan", 2, "Kyle", 3, "Kenny", 4, "Cartman"));
์ด์ „์— ๋งํ–ˆ๋“ฏ์ด HashMap ์—์„œ ํ‚ค๋Š” ์ •์ˆ˜์ด๊ณ  ๊ฐ’์—๋Š” ์ผ๋ถ€ ๋ฌธ์ž์—ด(์ด ๊ฒฝ์šฐ์—๋Š” ๋ฌธ์ž ์ด๋ฆ„)์ด ํฌํ•จ๋ฉ๋‹ˆ๋‹ค. ์Œ, ์ผ€๋‹ˆ์—๊ฒŒ ๋‚˜์œ ์ผ์ด ์ผ์–ด๋‚ฌ๋‹ค๊ณ  ํ•ฉ์‹œ๋‹ค(์‚ฌ์šฐ์Šค ํŒŒํฌ ๋งŒํ™” ์‹œ๋ฆฌ์ฆˆ๋ฅผ ์•„๋Š” ๋…์ž๋“ค์€ ์ผ€๋‹ˆ์—๊ฒŒ ๋‚˜์œ ์ผ์ด ๊ฝค ์ž์ฃผ ์ผ์–ด๋‚ฌ๋‹ค๋Š” ๊ฒƒ์„ ํ™•์‹คํžˆ ์•Œ๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค). ๋”ฐ๋ผ์„œ ๊ทธ๋Ÿฐ ์ผ์ด ๋ฐœ์ƒํ•˜๋ฉด ์šฐ๋ฆฌ๋Š” ์ด ํšŒ์‚ฌ( HashMap )์—์„œ Kenny๋ฅผ ์ œ๊ฑฐํ•˜๊ณ  ๊ทธ๋ฅผ Butters๋ผ๋Š” ์ด๋ฆ„์˜ ๋‹ค๋ฅธ ์นœ๊ตฌ๋กœ ๊ต์ฒดํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด๋Š” ๊ฐ’ ์—…๋ฐ์ดํŠธ ์ž‘์—…์ด๊ธฐ ๋•Œ๋ฌธ์— ์ˆ˜ํ–‰ํ•˜๊ธฐ๊ฐ€ ๋งค์šฐ ์‰ฝ์Šต๋‹ˆ๋‹ค. ์šฐ๋ฆฌ ์ผ€๋‹ˆ ๋ณด์ด์˜ ์—ด์‡ ๋Š” == 3 ์ž…๋‹ˆ๋‹ค . Kenny๊ฐ€ ์žˆ๋Š” ํ‚ค 3์˜ ๊ฐ’์„ ๋ณ€๊ฒฝํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด๋ฅผ ์œ„ํ•ด put() ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค .
names.put(3, "Butters");
์ด ๊ฒฝ์šฐ ์ง€๋„๋ฅผ ํ™”๋ฉด์— ํ‘œ์‹œํ•˜๋ฉด ๊ฒฐ๊ณผ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
{1=Stan, 2=Kyle, 3=Butters, 4=Cartman}
Kenny์™€ ๋ชจ๋“  ๊ฒƒ์ด ์ž˜ ๋˜์–ด ๊ทธ๋ฅผ ํšŒ์‚ฌ์— ๊ณ„์† ์œ ์ง€ํ•˜๊ณ  ์‹ถ์ง€๋งŒ ๊ทธ์˜ ํ‚ค๋ฅผ ์—…๋ฐ์ดํŠธํ•ด์•ผ ํ•  ์ด์œ ๊ฐ€ ์žˆ๋‹ค๋ฉด ์–ด๋–ป๊ฒŒ ํ•ฉ๋‹ˆ๊นŒ? ๊ทธ๋Š” ๋” ์ด์ƒ 3์œ„๊ฐ€ ์•„๋‹ˆ๋ผ 5์œ„์ž…๋‹ˆ๋‹ค. ํ‚ค 5๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ Kenny๋ฅผ ์ง€๋„์— ๋‹ค์‹œ ๋„ฃ๊ณ  ๊ฒฐ๊ณผ๋ฅผ ์ธ์‡„ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. put ๋ฉ”์†Œ๋“œ๋ฅผ ์ž˜ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค . ์ด ์˜ˆ์ œ์˜ ์ „์ฒด ์ฝ”๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
import java.util.HashMap;

public class HashMapUpdKey {
   public static void main(String[] args) {
       Map<Integer, String> names = new HashMap<>(Map.of(1, "Stan", 2, "Kyle", 3, "Kenny", 4, "Cartman"));
       names.put(5, "Kenny");
       System.out.println(names);
   }
}
๊ฒฐ๊ณผ๊ฐ€ ์–ด๋–ป๊ฒŒ ๋ ์ง€ ์ด๋ฏธ ์ง์ž‘ํ•˜์…จ์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค.
{1=Stan, 2=Kyle, 3=Kenny, 4=Cartman, 5=Kenny}
์ด๊ฒƒ์ด ์šฐ๋ฆฌ๊ฐ€ ๊ธฐ๋Œ€ํ–ˆ๋˜ ๊ฒƒ์ž…๋‹ˆ๊นŒ? ์ด์ œ Kenny๋Š” HashMap ์— ๋‘ ๊ฐœ์˜ ํ‚ค๋ฅผ ๊ฐ€์ง€๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค . ์Œ, ์—„๋ฐ€ํžˆ ๋งํ•˜๋ฉด, ์šฐ๋ฆฌ์˜ ๊ฐ์ฒด๋Š” ํ‚ค์— ์˜ํ•ด ๊ณ ์œ ํ•˜๊ฒŒ ๊ฒฐ์ •๋˜๊ธฐ ๋•Œ๋ฌธ์— ์šฐ๋ฆฌ๊ฐ€ ์˜๋ฏธํ•˜๋Š” ๋ฐ”๊ฐ€ ๋ฌด์—‡์ด๋“  ์ด๋“ค์€ ๋‘ ๊ฐœ์˜ ๋‹ค๋ฅธ Kenny์ž…๋‹ˆ๋‹ค. ๊ทธ๊ฒƒ์€ ์‚ฌ๋žŒ์˜ ์—ฌ๊ถŒ๊ณผ ๊ฐ™์œผ๋ฉฐ ๊ณ ์œ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ํ•ด์‹œ๋งต ํ‚ค๋ฅผ ์ง์ ‘ ์ถ”๊ฐ€ํ•œ ํ›„์—๋Š” ์ด๋ฆ„์„ ๋ฐ”๊พธ๊ฑฐ๋‚˜ ์—…๋ฐ์ดํŠธํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ์ด ์ž‘์—…์€ ๋‹จ์ˆœํžˆ ์‚ฌ์šฉํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๊ธฐ๋งŒ์ ์ธ ์กฐ์ž‘์„ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ƒˆ ํ‚ค๋กœ ์ƒˆ ํ•ญ๋ชฉ์„ ์‚ฝ์ž…ํ•˜๊ณ  ์ด์ „ ํ•ญ๋ชฉ์„ ์‚ญ์ œํ•ฉ๋‹ˆ๋‹ค. ์ด๋Š” HashMap ์ œ๊ฑฐ ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•˜์—ฌ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. remove()๋Š” ์—ฐ๊ฒฐ์„ ์ œ๊ฑฐํ•  ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ ์‚ญ์ œ๋œ ๊ฐ’๋„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค(์ด์ „์— ์žˆ์—ˆ๋˜ ๊ฒฝ์šฐ). ์ด ์ž‘์—…์œผ๋กœ ์˜ˆ์ œ๋ฅผ ๋ณด์™„ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.
//easy replacement example
import java.util.HashMap;

public class HashMapUpdKey {
   public static void main(String[] args) {
      Map<Integer, String> names = new HashMap<>(Map.of(1, "Stan", 2, "Kyle", 3, "Kenny", 4, "Cartman"));

       names.put(5, "Kenny"); //Adding โ€œnewโ€ Kenny
       System.out.println(names.remove(3)); //Update value of the key: Removing โ€œoldโ€ Kenny and print out deleted value

       System.out.println(names);
   }
}
์ด์ œ ๋งˆ์นจ๋‚ด ํ•„์š”ํ•œ ๊ฒƒ์„ ์–ป์—ˆ๊ณ  Kenny๋ฅผ ์ฐพ์„ ์ˆ˜ ์žˆ๋Š” ํ‚ค๋ฅผ ์—…๋ฐ์ดํŠธํ–ˆ์Šต๋‹ˆ๋‹ค. ๊ฒฐ๊ณผ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.
์ผ€๋‹ˆ {1=์Šคํƒ , 2=์นด์ผ, 4=์นดํŠธ๋งจ, 5=์ผ€๋‹ˆ}
๋ฌผ๋ก  "์ด์ „" Kenny๋ฅผ ์ œ๊ฑฐํ•˜๊ณ  ์ƒˆ Kenny๋ฅผ ์ˆœ์„œ์— ๊ด€๊ณ„์—†์ด ์ถ”๊ฐ€ํ•˜๋Š” ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋“ค์€ ๋ณธ์งˆ์ ์œผ๋กœ ๋…๋ฆฝ์ ์ž…๋‹ˆ๋‹ค. ๋˜๋Š” ํ•œ ์ค„๋งŒ ์‚ฌ์šฉํ•˜์—ฌ ์ฝ”๋“œ๋ฅผ ์ค„์ด์‹ญ์‹œ์˜ค.
names.put(5, names.remove(3));
๊ฒฐ๊ณผ๋Š” ๋ฐ˜๋“œ์‹œ ๊ฐ™์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ Java HashMap ์—์„œ ํ‚ค๋ฅผ ๋ณ€๊ฒฝํ•˜๋Š” ์œ ์ผํ•œ ์ ์ ˆํ•œ ๋ฐฉ๋ฒ•์€ ํ•ญ๋ชฉ์„ ์‚ญ์ œํ•˜๊ณ  ์ƒˆ ํ‚ค์™€ ํ•จ๊ป˜ ๋™์ผํ•œ ๊ฐ’์„ ์‚ฝ์ž…ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•์œผ๋กœ ํ•  ์ˆ˜ ์žˆ์ง€๋งŒ ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ณ  ์ œ๊ฑฐํ•˜๋Š” ๊ฒƒ๊ณผ ๊ฑฐ์˜ ๊ฐ™์€ ์ด์•ผ๊ธฐ๊ฐ€ ๋  ๊ฒƒ์ž…๋‹ˆ๋‹ค.
์ฝ”๋ฉ˜ํŠธ
  • ์ธ๊ธฐ
  • ์‹ ๊ทœ
  • ์ด์ „
์ฝ”๋ฉ˜ํŠธ๋ฅผ ๋‚จ๊ธฐ๋ ค๋ฉด ๋กœ๊ทธ์ธ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค
์ด ํŽ˜์ด์ง€์—๋Š” ์•„์ง ์ฝ”๋ฉ˜ํŠธ๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค