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 ์์ ํค๋ฅผ ๋ณ๊ฒฝํ๋ ์ ์ผํ ์ ์ ํ ๋ฐฉ๋ฒ์ ํญ๋ชฉ์ ์ญ์ ํ๊ณ ์ ํค์ ํจ๊ป ๋์ผํ ๊ฐ์ ์ฝ์
ํ๋ ๊ฒ์
๋๋ค. ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ํ ์ ์์ง๋ง ์์๋ฅผ ์ถ๊ฐํ๊ณ ์ ๊ฑฐํ๋ ๊ฒ๊ณผ ๊ฑฐ์ ๊ฐ์ ์ด์ผ๊ธฐ๊ฐ ๋ ๊ฒ์
๋๋ค.