์•ˆ๋…•! ์˜ค๋Š˜ ์ˆ˜์—…์—์„œ๋Š” Java Iterator์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. ๋„์„œ๊ด€์— ๊ฐ€์„œ ํŠน์ • ์ฑ…์„ ์ฐพ๊ณ  ์‹ถ๋‹ค๊ณ  ์ƒ์ƒํ•ด ๋ณด์‹ญ์‹œ์˜ค. ์–ด๋–ป๊ฒŒ ํ•ฉ๋‹ˆ๊นŒ? ๋…ผํ”ฝ์…˜์ด๋ผ๋ฉด Dewey Decimal System์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์†Œ์„ค์ธ ๊ฒฝ์šฐ ์„ฑ์˜ ์•ŒํŒŒ๋ฒณ์ˆœ์œผ๋กœ ์ •๋ ฌ๋ฉ๋‹ˆ๋‹ค. ๋‹น์‹ ์ด ๋ฌด์—‡์„ ์ฐพ๊ณ  ์žˆ๋“ , ์–ธ์  ๊ฐ€๋Š” ๋‹น์‹ ์ด ์ฐพ๊ณ  ์žˆ๋Š” ๊ฒƒ์„ ์ฐพ์„ ๋•Œ๊นŒ์ง€ ํ•œ ๋ฒˆ์— ํ•œ ๊ถŒ์”ฉ ์ฑ…์„ ๋’ค์ ธ์•ผ ํ•ฉ๋‹ˆ๋‹ค. Array , ArrayList , Queue ๋˜๋Š” List ์— ์ €์žฅ๋˜์–ด ์žˆ๋Š”์ง€ ์—ฌ๋ถ€์— ๊ด€๊ณ„์—†์ด Java์— ํ•ญ๋ชฉ ๋ชจ์Œ์ด ์žˆ์„ ๋•Œ๋งˆ๋‹ค ํŠน์ • ๊ฐ’์„ ์–ด๋–ป๊ฒŒ ์ฐพ์Šต๋‹ˆ๊นŒ? ์–ด๋Š ์‹œ์ ์—์„œ ๊ฐ ์š”์†Œ๋ฅผ ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์”ฉ ํ†ต๊ณผํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ์ด Java iterator์˜ ๋ชฉ์ ์ž…๋‹ˆ๋‹ค.Java Iterator ์‚ฌ์šฉ ๋ฐฉ๋ฒ•: ๊ฐ„๋žตํ•œ ์ž์Šต์„œ - 1

์ž๋ฐ”์—์„œ Iterator๋ž€?

์ž๋ฐ”์—์„œ ์ดํ„ฐ๋ ˆ์ดํ„ฐ๋ž€? ์ปฌ๋ ‰์…˜์˜ ๊ฐ ์š”์†Œ๋ฅผ ๋ณด๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค. ์ปฌ๋ ‰์…˜์ด๋ž€ Collection ํด๋ž˜์Šค์— ์žˆ๋Š” ๋ชจ๋“  ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์—๋Š” ๋‹ค์Œ์ด ํฌํ•จ๋ฉ๋‹ˆ๋‹ค.
  • ๋ฐฐ์—ด๋ชฉ๋ก
  • ํ•ด์‹œ์…‹
  • LinkedHashSet
  • LinkedList
  • ์šฐ์„ ์ˆœ์œ„ ๋Œ€๊ธฐ์—ด
  • ๋ฒกํ„ฐ
  • ๊ทธ๋ฆฌ๊ณ  ๋งŽ์€ ๋‹ค๋ฅธ ์‚ฌ๋žŒ๋“คโ€ฆ
๋˜ํ•œ Set , List , Queue , Dequeue ๋ฐ Sorted Set ๊ณผ ๊ฐ™์€ ํด๋ž˜์Šค์— ๋Œ€ํ•œ ๋‹ค์–‘ํ•œ ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ํฌํ•จํ•ฉ๋‹ˆ๋‹ค . Iterator<E> ๋Š” Interface Iterator<E> ํด๋ž˜์Šค์˜ ๊ณต์šฉ ์ธํ„ฐํŽ˜์ด์Šค ๋ฉ”์„œ๋“œ์ž…๋‹ˆ๋‹ค. Java 1.2์—์„œ ๋„์ž…๋˜์—ˆ์œผ๋ฉฐ ์ปฌ๋ ‰์…˜์˜ ์ˆœ์ฐจ์  ์š”์†Œ๋ฅผ ๊ฒ€์‚ฌํ•˜๋Š” ๋ฐฉ๋ฒ•์œผ๋กœ Enumeration์„ ๋Œ€์ฒดํ–ˆ์Šต๋‹ˆ๋‹ค.

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