์ด ๊ฒ์๋ฌผ์์๋ Java์์ Map์ ๋ฐ๋ณตํ๋ ๋ค์ํ ๋ฐฉ๋ฒ์ ๋ฐฐ์๋๋ค. ๋ช ๊ฐ์ง ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ๊ณผ ์๋ฅผ ํตํด ์ด๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์
๋๋ค. ์์ํ๊ธฐ ์ ์ Java์
์ธํฐํ์ด์ค ์
๋งต์ ์ดํดํ๊ณ ์๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ฌ๊ธฐ์ ๊ฐ๋จํ ์์ฝ์ด ์์ต๋๋ค.
Java์์ ๋งต์ด๋ ๋ฌด์์
๋๊น?
์ด์ ๋ํ ํด์์ ๋ค์ํ์ง๋ง ๊ฐ๋จํ ์ด๋ ๊ฒ ํํํด ๋ณด์.
"์ง๋๋ ํค-๊ฐ ์์ ํํ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฐ ์ฌ์ฉ๋๋ Java์ ์ธํฐํ์ด์ค์
๋๋ค."
์ง๋๊ฐ ๋ฌด์์ ์ฌ์ฉ๋๋์ง ์๊ฐํ๊ณ ์๋ค๋ฉด? ์๋๋ฉด ์ธ์ ํ์ํฉ๋๊น? ๊ทธ๋ฐ ๋ค์ ์ค์ํ์์ ๋ฐ์ดํฐ๋ฅผ ํค-๊ฐ ์์ผ๋ก ์ ์ฅํด์ผ ํ๋ ์ํฉ์ด ๋ง์ด ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ์ฌ์ ์์ ํ ๊ธ์์ ํด๋นํ๋ ๋ชจ๋ ๋จ์ด๋ Java์์ ๋งต ํํ๋ก ์ ์ฅํ ์ ์์ต๋๋ค.
์ผ์ด |
์ฐ, ์, ํ๊ตญ, ๊ธฐ์ฌ, ... ๋ฑ |
์ |
์ฉ์, ์๋ช
, ๋น, ์ฌ๋, ๋ ๋ฐ๋
ผ, ... ๋ฑ |
๋ํ ๋ค์ ์๋ฅผ ๋ณด๋ฉด ์ด๋ฅผ ๋ ์ ์ดํดํ ์ ์์ต๋๋ค.
์ด์ |
๊ฐ |
๊ฐ์กฑ ID |
๊ฐ์กฑ ๊ตฌ์ฑ์๋ค |
ํด๋์ค ์ด๋ฆ |
ํ์์ฆ |
์ง์ญ ์ด๋ฆ |
์ฐํธ๋ฒํธ |
์์ญ ๋ธ๋ก |
์ง ๋ฒํธ |
๋งต์ ๋ฐ๋ณตํด์ผ ํ๋ ์ด์ ๋ ๋ฌด์์
๋๊น?
๋ฐ์ดํฐ ์ก์ธ์ค, ์์ ๋๋ ์ ๊ฑฐ๋ฅผ ์ํด ๋งต์ ์ํํ๊ฑฐ๋ ๋ฐ๋ณตํด์ผ ํฉ๋๋ค. ์ฐ๋ฆฌ๊ฐ ๊ฐ์ง ๋ช ๊ฐ์ง ์ต์
์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
Java์์ ๋งต์ ๋ฐ๋ณตํ๋ ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ ๋ฌด์์
๋๊น?
๋งต์ ํก๋จํ๋ ๋ฐฉ๋ฒ์ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์์ง๋ง. ๊ทธ๋ฌ๋ ๊ฐ์ฅ ํจ์จ์ ์ด๊ณ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ ์ค์ ์ ๋ ๊ฒ์
๋๋ค.
- ForEach ๋ฃจํ ๋ฐฉ๋ฒ
- ๋ฐ๋ณต์ ๋ฐฉ๋ฒ
์๋์์ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๊ตฌํ์ ์ฐพ์ผ์ญ์์ค.
Foreach ๋ฃจํ ๋ฐฉ๋ฒ ์ฌ์ฉ
์
import java.util.Map;
import java.util.HashMap;
public class ForEachDemo {
public static void main(String[] args) {
Map<String, String> businessDays = new HashMap<String, String>();
// store business days i-e; key/value pairs in the Map
businessDays.put("1", "Monday");
businessDays.put("2", "Tuesday");
businessDays.put("3", "Wednesday");
businessDays.put("4", "Thursday");
businessDays.put("5", "Friday");
// Iterating over the Map.entrySet() using map.forEach
for (Map.Entry<String, String> entry : businessDays.entrySet())
{
System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
}
}
}
์ฐ์ถ
ํค = 1, ๊ฐ = ์์์ผ ํค = 2, ๊ฐ = ํ์์ผ ํค = 3, ๊ฐ = ์์์ผ ํค = 4, ๊ฐ = ๋ชฉ์์ผ ํค = 5, ๊ฐ = ๊ธ์์ผ
์ค๋ช
์ด ์์ ์์๋ foreach ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ ๋งต์ ๋ฐ๋ณตํ์ต๋๋ค. for-each ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ ํค-๊ฐ ์์ ํํ๋ก ๋งต์์ ๋ฐ์ดํฐ์ ์๋ํ๋ "๋ณด๊ธฐ"๋ฅผ ์ ๊ณตํ๋
entrySet()์ ์ป์ต๋๋ค. ๊ฐ entrySet์๋ ํค์ ํด๋น ๊ฐ์ด ํฌํจ๋์ด ์์ต๋๋ค. ์๊ตฌ ์ฌํญ์ ๋ฐ๋ผ
Map.Entry<key, value> ์ ๋ชจ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค . ์ฌ๊ธฐ์๋ ์ฝ์์ ๋ฐ์ดํฐ๋ฅผ ํ์ํ๊ธฐ ์ํด
getKey() ๋ฐ
getValue() ๋ง ์ฌ์ฉํ์ต๋๋ค . ์ฐ์ต์ผ๋ก ์ด ๊ฐ๋
์ ๋ํ ๋ช
๋ น์ ๊ฐํํ๊ธฐ ์ํ ๋๋จธ์ง ๋ฐฉ๋ฒ์ ํ์ํ ์ ์์ต๋๋ค.
๋ฐ๋ณต์ ๋ฐฉ๋ฒ ์ฌ์ฉ
์
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class MapIterator {
public static void main(String[] args) {
Map<String, String> monthsInAYear = new HashMap<String, String>();
// store business days i-e; key/value pairs in the Map
monthsInAYear.put("1", "January");
monthsInAYear.put("2", "February");
monthsInAYear.put("3", "March");
monthsInAYear.put("4", "April");
monthsInAYear.put("5", "May");
monthsInAYear.put("6", "June");
monthsInAYear.put("7", "July");
monthsInAYear.put("8", "August");
monthsInAYear.put("9", "September");
monthsInAYear.put("10", "October");
monthsInAYear.put("11", "November");
monthsInAYear.put("12", "December");
// iterate map / traverse the map using using iterator
Iterator<Map.Entry<String, String>> iterator = monthsInAYear.entrySet().iterator();
while (iterator.hasNext())
{
// check if next entry exists in the map
Map.Entry<String, String> entry = iterator.next();
System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
}
}
}
์ฐ์ถ
ํค = 11, ๊ฐ = 11์ ํค = 1, ๊ฐ = 1์ ํค = 12, ๊ฐ = 12์ ํค = 2, ๊ฐ = 2์ ํค = 3, ๊ฐ = 3์ ํค = 4, ๊ฐ = 4์ ํค = 5, ๊ฐ = 5์ ํค = 6, ๊ฐ = 6์ ํค = 7, ๊ฐ = 7์ ํค = 8, ๊ฐ = 8์ ํค = 9, ๊ฐ = 9์ ํค = 10, ๊ฐ = 10์
์ค๋ช
์ด ์์ ์์๋ ๋งต์ ์ํ/๋ฐ๋ณตํ ๋ช
์์ ๋ฐ๋ณต์๋ฅผ ๋ง๋ญ๋๋ค. ๋จผ์ ๋ฐ๋ณต์ ํด๋์ค๋ฅผ ๊ฐ์ ธ์จ ๋ค์ entrySet์ ๋ํ ๋ฐ๋ณต์๋ฅผ ๊ฐ์ ธ์์ผ ํฉ๋๋ค. ์ด์ ์ง๋์ ์กด์ฌํ๋ ๋ค์ ์ํฐํฐ๋ฅผ ๊ณ์ ํ์ธํ๋ฉด์ ์ง๋๋ฅผ ํก๋จํฉ๋๋ค. ์! ์ํ๊ฐ ์ด๋ ๊ฒ ์๋ฃ๋์์ต๋๋ค.
Foreach ๋ฃจํ๊ฐ ๋ฐ๋ณต์ ๋ฐฉ๋ฒ๋ณด๋ค ๋ซ์ต๋๊น?
์์
์ ์ํํ๋ ํ ๋งต ์ํ์ ์ด๋ค ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋์ง๋ ์ค์ํ์ง ์์ต๋๋ค.
์ฑ๋ฅ ์ธก๋ฉด์์ for-each ๋ฃจํ์ ๋ฐ๋ณต์๋ ๋ชจ๋ ๋์ผํ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ต๋๋ค . ๋ฐ๋ผ์ ์ด๋ ๊ฒ๋ ๋ค๋ฅธ ๊ฒ๋ณด๋ค ๋ซ์ง ์์ผ๋ฉฐ, ์ธ์ ์ฌ์ฉํด์ผ ํ๋์ง์ ๋ฐ๋ผ ๋ค๋ฆ
๋๋ค.
๋ ๋ฐฉ๋ฒ์ ์ฐจ์ด์ ์ ๋ฌด์์
๋๊น?
for-each ๋ฃจํ๋ ๋งต์ ๋ฐ์ดํฐ ์
๋ฐ์ดํธ/์์ ์ ํ์ฉํ์ง ์์ต๋๋ค. ๋ฐ๋๋ก ๋ฐ๋ณต์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ฒ ์์ ํ ์ ์์ต๋๋ค. iterators ํด๋์ค๋ ๋งต์์ ๋ฐ์ดํฐ๋ฅผ ํธ์ง/์ ๊ฑฐํ๋ ๊ตฌํ์ ์ ๊ณตํ์ฌ ์ฌ์ฉ์๋ฅผ ์ฉ์ดํ๊ฒ ํฉ๋๋ค. ๋ฐ๋๋ก for-each ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ ์ง๋ ๋ฐ์ดํฐ๋ฅผ ํธ์ง/์ญ์ ํ๋ ค๊ณ ํ๋ฉด ConcurrentModificationException ์ด ๋ฐ์
ํฉ๋๋ค . ๊ทธ ์ด์ ๋ for-each ๋ฃจํ๊ฐ ์ฌ์ฉ์์๊ฒ ๋
ธ์ถ๋์ง ์๋ ๋ฐ๋ณต์๋ฅผ ์์์ ์ผ๋ก ์์ฑํ๊ธฐ ๋๋ฌธ์
๋๋ค. ๋ฐ๋ผ์ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฑฐ๋ ์ญ์ ํ ์ ์๋ ์ก์ธ์ค ๊ถํ์ด ์์ต๋๋ค.
์ด๋ค ์ํ ๋ฐฉ๋ฒ์ ์ธ์ ์ฌ์ฉํ ๊ฒ์ธ๊ฐ?
๋งต์ ๋ฐ๋ณตํ๊ธฐ ์ํด for-each ๋๋ ๋ฐ๋ณต์๋ฅผ ์ฌ์ฉํ ์ง ํ์คํ์ง ์์ ๊ฒฝ์ฐ ๋ค์ ์ ์์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- ๋งต์ ์์ ํด์ผ ํ๋ ๊ฒฝ์ฐ ๋ฐ๋ณต์๋ฅผ ์ฌ์ฉํ์ญ์์ค .
- ์ค์ฒฉ๋ ๋ฃจํ๊ฐ ์๋ ๊ฒฝ์ฐ for-each ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ญ์์ค (๋ณต์ก์ฑ์ ํผํ๊ธฐ ์ํด).
๊ฒฐ๋ก
๊ฒ์๋ฌผ์ด ๋๋ ๋๊น์ง Java์์ ๋งต์ ๋ฐ๋ณตํ๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ ๊ธฐ๋ฅผ ๋ฐ๋๋๋ค. ์ด๋ฅผ ์ฐ์ตํ๊ณ ๋ค๋ฅธ ์ํ ๋ฐฉ๋ฒ๋ ์๋ํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ๋งํ ๋๋์ด ๋ค ๋๋ง๋ค ์ธ์ ๋ ์ง ๋ค๋ก ๋์๊ฐ๊ฑฐ๋ ์ง๋ฌธ์ ๊ฒ์ํ์ธ์. ๊ทธ๋๊น์ง, ํ๋ณตํ ํ์ต!
GO TO FULL VERSION