์๋
! ์ค๋ ์์
์์๋ Java Iterator์ ๋ํด ์ด์ผ๊ธฐํ๊ฒ ์ต๋๋ค. ๋์๊ด์ ๊ฐ์ ํน์ ์ฑ
์ ์ฐพ๊ณ ์ถ๋ค๊ณ ์์ํด ๋ณด์ญ์์ค. ์ด๋ป๊ฒ ํฉ๋๊น? ๋
ผํฝ์
์ด๋ผ๋ฉด Dewey Decimal System์ด ์์ต๋๋ค. ์์ค์ธ ๊ฒฝ์ฐ ์ฑ์ ์ํ๋ฒณ์์ผ๋ก ์ ๋ ฌ๋ฉ๋๋ค. ๋น์ ์ด ๋ฌด์์ ์ฐพ๊ณ ์๋ , ์ธ์ ๊ฐ๋ ๋น์ ์ด ์ฐพ๊ณ ์๋ ๊ฒ์ ์ฐพ์ ๋๊น์ง ํ ๋ฒ์ ํ ๊ถ์ฉ ์ฑ
์ ๋ค์ ธ์ผ ํฉ๋๋ค. Array , ArrayList , Queue ๋๋ List ์ ์ ์ฅ๋์ด ์๋์ง ์ฌ๋ถ์ ๊ด๊ณ์์ด Java์ ํญ๋ชฉ ๋ชจ์์ด ์์ ๋๋ง๋ค ํน์ ๊ฐ์ ์ด๋ป๊ฒ ์ฐพ์ต๋๊น? ์ด๋ ์์ ์์ ๊ฐ ์์๋ฅผ ํ ๋ฒ์ ํ๋์ฉ ํต๊ณผํด์ผ ํฉ๋๋ค. ์ด๊ฒ์ด Java iterator์ ๋ชฉ์ ์
๋๋ค.
์๋ฐ์์ Iterator๋?
์๋ฐ์์ ์ดํฐ๋ ์ดํฐ๋? ์ปฌ๋ ์ ์ ๊ฐ ์์๋ฅผ ๋ณด๋ ๋ฐฉ๋ฒ์ ๋๋ค. ์ปฌ๋ ์ ์ด๋ Collection ํด๋์ค์ ์๋ ๋ชจ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ์ฌ๊ธฐ์๋ ๋ค์์ด ํฌํจ๋ฉ๋๋ค.- ๋ฐฐ์ด๋ชฉ๋ก
- ํด์์
- LinkedHashSet
- LinkedList
- ์ฐ์ ์์ ๋๊ธฐ์ด
- ๋ฒกํฐ
- ๊ทธ๋ฆฌ๊ณ ๋ง์ ๋ค๋ฅธ ์ฌ๋๋คโฆ
Java์์ ๋ฐ๋ณต์๋ก For ๋ฃจํ๋ฅผ ์ฌ์ฉํ๋ฉด ์ ๋๋ ์ด์
๋ชจ๋ ์ฌ๋์ด Java์์ ์ปฌ๋ ์ ์ ๋ฐ๋ณตํ๋๋ก ๊ฐ๋ฅด์น๋ ์ฒซ ๋ฒ์งธ ๋ฐฉ๋ฒ ์ค ํ๋๋ ๋ฃจํ์ ๋๋ค. ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
class Main {
public static void main(String[] args) {
int exampleArray[] = new int[10];
//fill array with data
for(int x = 0; x < exampleArray.length; x++) {
System.out.println("Content of element " + x + "is: " + exampleArray[x]);
}
}
}
์ถ๋ ฅ์ ๋ค์๊ณผ ๊ฐ์ ๋ชฉ๋ก์
๋๋ค.
Content of element 0 is: 0
Content of element 1 is: 1
Content of element 2 is: 2
etc.โฆ
์ด๊ฒ์ ์ฉ๋๊ฐ ์์ง๋ง ์ปฌ๋ ์
์ด ์ธ๋ฑ์ค ๊ธฐ๋ฐ ์์คํ
์ ์์๋ฅผ ์ ์ฅํ์ง ์์ผ๋ฉด ์ด๋ป๊ฒ ๋ ๊น์? ์๋ฅผ ๋ค์ด Set ์๋ ์ผ๋ฐ์ ์ผ๋ก ์์๊ฐ ์์ต๋๋ค. ๋ฐ๋ผ์ Java์์ ๋ฐ๋ณต์๋ก for ๋ฃจํ๋ฅผ ์ฌ์ฉํ๋ ๊ดํ์์ ๋ฒ์ด๋ ๋์ Iterator<E> ํด๋์ค ๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ์ตํ๋ ๊ฒ์ด ์ข์ต๋๋ค . ๋ค์์ ๋ช ๊ฐ์ง Java ๋ฐ๋ณต๊ธฐ ์์ ์
๋๋ค.
Java์์ Iterator๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
๋ค์์ Java์์ ๋ฐ๋ณต์๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ํ ๋ช ๊ฐ์ง ์์ ๋๋ค. ๋ฐ๋ณต์ ํด๋์ค๋ฅผ ์ฌ์ฉํ ๋ ์ปฌ๋ ์ ์ ์ํํ๋ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค. while() ๋ฃจํ, for() ๋ฃจํ ๋ฐ forEach() ๋ฃจํ๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค . ์ด for ๋ฃจํ๋ ์ด์ ์ ์ด์ผ๊ธฐํ ๋ฃจํ์ ๋ค๋ฆ ๋๋ค. ๋ค์์ ์ธ ๊ฐ์ง ๋ค๋ฅธ Java ๋ฐ๋ณต๊ธฐ ์์ ์ ๋๋ค. ๋จผ์ ๋ฐ๋ณตํ ์ปฌ๋ ์ ์ ์ค์ ํด ๋ณด๊ฒ ์ต๋๋ค .
import java.util.*; // imports ArrayList, Collection and Iterator
class Main {
public static void main(String[] args) {
Collection<String> example = new ArrayList<String>();
example.add("Item 1");
example.add("Item 2");
example.add("Item 3");
example.add("Item 4");
}
}
์ด๊ฒ์ 4๊ฐ์ ํญ๋ชฉ์ ๋ก๋ํ ArrayList ๋ก ๊ตฌ์ฑ๋ ๊ฐ๋จํ ์ปฌ๋ ์
์
๋๋ค. ์ด์ Iterator ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ArrayList๋ฅผ ์ํํ๋ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์ดํด๋ณด๊ฒ ์ต๋๋ค .
๋์() ๋ฃจํ
Iterator<String> iterator = example.iterator();
while (iterator.hasNext()) {
System.out.println("Element Value= " + iterator.next());
}
์ด while() ๋ฃจํ๋ ๋ฏธ๋ ์์๊ฐ ์๋์ง ํ์ธํ๊ธฐ ์ํด Iterator ํด๋์ค์ .hasNext() ๋ถ์ธ ๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ ์ ์กฐ๊ฑด์ด ์ฐธ์ด๋ฉด ์งํํฉ๋๋ค. false๋ก ๋ฐํ๋๋ฉด ๋ฃจํ๊ฐ ์ข
๋ฃ๋ฉ๋๋ค. ์ฌ๊ธฐ์ ํต์ฌ ๋ถ๋ถ์ .hasNext() ๋ฐ .next() ๋ฉ์๋๊ฐ ๋ชจ๋ ์ฒซ ๋ฒ์งธ ์์์ ์ด๊ธฐ ๊ฒ์ฌ๋ฅผ ์ํํ๋ค๋ ๊ฒ์
๋๋ค. Collection ์ด ๋น์ด ์๊ณ ์ฒซ ๋ฒ์งธ ์์๊ฐ ์์ผ๋ฉด ๋ฉ์๋๋ .hasNext() ์ ๋ํด false๋ฅผ ๋ฐํํ๊ณ .next() ๋ฉ์๋ ์ ๋ํด NoSuchElementException์ ๋ฐ์์ํต๋๋ค .
for ๋ฃจํ
for (Iterator<String> iterator = example.iterator(); iterator.hasNext();) {
System.out.println("Element Value= " + iterator.next());
}
์ด๊ฒ์ ๋ณด๋ค ์ ํต์ ์ธ for ๋ฃจํ์ฒ๋ผ ๋ณด์
๋๋ค. ์กฐ๊ฑด ํ์ธ ๋ฐ ๋ณ๊ฒฝ ๋ถ๋ถ์ผ๋ก .hasNext() ๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค . ์ด๊ธฐํ๋ Iterator์ ๋ํ ํธ์ถ์
๋๋ค.
For:๊ฐ ๋ฃจํ
for (String s : example) {
System.out.println("Element Value= " + s);
}
For :Each ๋ฃจํ๋ for ๋ฃจํ์ด์ง๋ง ์ฝ๋ ๋ฐฉ๋ฒ์ ๋ชจ๋ฅธ๋ค๋ฉด ์กฐ๊ธ ํผ๋์ค๋ฌ์ธ ์ ์์ต๋๋ค. For:Each ๋ฃจํ ์ ๊ตฌ๋ฌธ์ for (data_type variableName : collectionName){ body} ์
๋๋ค . ์ด for:each ๋ฃจํ์๋ ๋ช ๊ฐ์ง ๋จ์ ์ด ์์ต๋๋ค. ์ฒซ์งธ, ์ปฌ๋ ์
์ ํ ๋ฐฉํฅ์ผ๋ก๋ง ์ด๋ํ ์ ์์ต๋๋ค. ๋์งธ, ๊ฐ ์์๋ฅผ ๋ฐ๋ณตํด์ผ ํฉ๋๋ค. ๋น์ ์ ๊ทธ๋ค ์ค ํ๋๋ฅผ ๊ฑด๋ ๋ธ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ Java์ ํธ๋ฆฌํ ๋ชฉ๋ก ๋ฐ๋ณต์๋ก์ ์ด๊ฒ์ด ์ต์ ์ ์ ํ์
๋๋ค. ํ๋ฌ์ค ์ธก๋ฉด์์ for:each ๋ฃจํ๋ ์ฝ๊ธฐ๊ฐ ๋งค์ฐ ์ฝ๊ณ ์ผ๋จ ์๊ณ ๋๋ฉด ์๋ชปํ๊ธฐ๊ฐ ์ด๋ ต์ต๋๋ค. ์ธ ๋ฐ๋ณต์ ๋ฃจํ์ ์ถ๋ ฅ์ด ๋ฌด์์ธ์ง ๊ถ๊ธํ๋ค๋ฉด ๋ชจ๋ ๋์ผํฉ๋๋ค.
Element Value= Item 1
Element Value= Item 2
Element Value= Item 3
Element Value= Item 4
Java For Maps์์ Iterator๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ
๋งต์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฐ ๋๋ฆฌ ์ฌ์ฉ๋๋ ๋ฐฉ๋ฒ์ด์ง๋ง Collection ์ ํ์ฅํ์ง ์๊ธฐ ๋๋ฌธ์ ์ด์ ๋ฐ๋ณต๊ธฐ๋ฅผ ์ฌ์ฉํ์ฌ ๋งต์ ์ง์ ํ์ํ ์ ์์ต๋๋ค. ๊ทธ๋ ๋ค๋ฉด Java์์ ๋ฐ๋ณต์๋ฅผ ์ฌ์ฉํ์ฌ Map ๋ฐ HashMap ์ ์ดํด๋ณด๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ ๋๊น ? ๋ค ๊ฐ์ง ์ข์ Java ๋งต ๋ฐ๋ณต์ ๋ฉ์๋๊ฐ ์์ต๋๋ค. ์ฐ๋ฆฌ๋ ๊ทธ๊ฒ๋ค์ ๊ฐ๋ณ์ ์ผ๋ก ๋ค๋ฃฐ ๊ฒ์ ๋๋ค. ๋จผ์ ์ผ๋ จ์ ๊ฐ์ด ์๋ ์ง๋๋ฅผ ๋ก๋ํด ๋ณด๊ฒ ์ต๋๋ค.
import java.util.*; //imports Map and HashMap
class Main {
public static void main(String[] args) {
Map<String, String> example = new HashMap<String, String>();
example.put("alpha", "one");
example.put("beta", "two");
example.put("gamma", "three");
}
}
Java ํด์๋งต ๋ฐ๋ณต์ ๋ฉ์๋: forEach(action)
example.forEach((k,v) -> System.out.println("Key: "+ k + ", Value: " + v));
์ด ๋ฉ์๋๋ ๋๋ค ์์ ์ฌ์ฉํ์ฌ ๋ฐ๋ณตํฉ๋๋ค. ๋๋ค ์ฐ์ฐ์๋ forEach() ๋ฉ์๋์ด๋ฉฐ ๋ณธ๋ฌธ์ ๊ฐ์ ์ถ๋ ฅํฉ๋๋ค. ์ด๊ฒ์ ๋ค์ค ๋งค๊ฐ๋ณ์ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ด๊ฒ์ Java 8์์ ๋งต ๋ฐ๋ณต์๋ฅผ ์ํ ๊ฐ์ฅ ๋น ๋ฅด๊ณ ๊นจ๋ํ ๋ฐฉ๋ฒ์
๋๋ค.
Java ํด์๋งต ๋ฐ๋ณต์ ๋ฉ์๋: For:Each() ๋ฃจํ
for (Map.Entry<String, String> iterate : example.entrySet()) {
System.out.println("Key: " + iterate.getKey() + ", Value: " + iterate.getValue());
}
์ด๋ For:Each ๊ตฌ๋ฌธ์ ์ฌ์ฉํ์ฌ entrySet() ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ํค์ ๊ฐ์ ์์๋ก ํฌํจํ๋ ์งํฉ์ ๋ฐํํฉ๋๋ค. ๋ํ .Entry() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ๋ ๊ฐ์ฒด๋ ์ด ๋ฐ๋ณต์ด ๋ฐ์ํ๋ ๋์์๋ง ์ฐธ์
๋๋ค.
Java ํด์๋งต ๋ฐ๋ณต์ ๋ฉ์๋: Map.Entry<k, v>
Iterator<Map.Entry<String, String>> iterator = example.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<String, String> element = iterator.next();
System.out.println("Key: " + element.getKey() + ", Value: " + element.getValue());
)
์ด ๋ฉ์๋๋ Collections Iterator ๋ฐ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด Map์ ์งํฉ์ผ๋ก ๋ค์ ๋ณํํฉ๋๋ค . ์ด ์ธ ๊ฐ์ง ๋ฐ๋ณต์ ๋ฉ์๋์ ๊ฒฝ์ฐ ๋ฐํ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
Key: alpha, Value: one
Key: beta, Value: two
Key: gamma, Value: three
Java Hashmap Iterator Method: keySet() and values()
for (String key : example.keySet()) {
System.out.println("Key: " + key);
}
for (String value : example.values()) {
System.out.println("Value: " + value);
}
์ด๊ฒ์ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ์์๋ฅผ ๋ฐํํฉ๋๋ค. ๋จผ์ ๋ชจ๋ ํค๋ฅผ ์์๋๋ก ๋ฐํํ ๋ค์ ๋ชจ๋ ๊ฐ์ ๋ฐํํฉ๋๋ค.
Key: alpha
Key: beta
Key: gamma
Value: one
Value: two
Value: three
GO TO FULL VERSION