Iterator Pattern က behaviour pattern တစ်ခုပါ။​ Composite Pattern လိုမျိုး code တွေမှာ ဆိုရင် အဆုံးကို မသိနိုင်ပါဘူး။ Directory အောက်မှာ Directory တွေက တောက်လျှောက် ရှိနိုင်တယ်။ Tree ကို traversal သွားရင် BFS နဲ့ DFS algorithm နှစ်ခု ရှိပါတယ်။

နှစ်သက်ရာနဲ့ သွားလို့ ရအောင်လည်း လုပ်ချင်တယ် ဆိုရင် Iterator pattern က ပို အဆင်ပြေပါတယ်။ Iterator Pattern က loop လုပ်ရသည့် အခါတွေ မှာ သုံးလို့ရပါတယ်။

Class Diagram ကို ကြည့်ရအောင်။

ကျွန်တော်တို့ Directory နဲ့ ပေါင်းပြီး ရေးကြည့်ရေအာင်။

DFS နဲ့ သွားချင်ရင် FileComponent ကို DFSIterator မှာ parse ပေးပြီး သွားလိုက်ရုံပါပဲ။ BFSInterator ဆိုလည်း အဲဒီ အတိုင်းပါပဲ။

DFSIterator iterator = new DFSIterator(rootComponent);
while (iterator.hasNext()) {
    FileComponent component = iterator.next()
    componet.print();
}

ဒီ code မှာ .next() ဆိုတာကို တွေ့မှာပါ။ Iterator က pointer နဲ့ သွားတာပါ။ hasNext()ဆိုရင် next ရှိမရှိ စစ်ပြီးတော့ next() ဆိုရင်တော့ လက်ရှိ pointer က value ကို return ပြန်တယ်။ Pointer ကို ရှေ့တိုးသွားမှာပါ။

ကျွန်တော်တို့ Array ကို Reverse Iterator နဲ့ ရေးကြည့်ရအောင်။

Java မှာ Iterator အတွက် Interface ရှိထားပြီးသားပါ။

public class ReverseArrayIterator<T> implements Iterator<T> {

    private final List<T> list;
    private int position;
    public ReverseArrayIterator(List<T> list) {
        this.list = list;
        this.position = list.size() - 1;
    }


    public Iterator<T> iterator() {
        return this;
    }


    @Override
    public boolean hasNext() {
        return position >= 0;
    }

    @Override
    public T next() {
        return list.get(position--);
    }
}

Code လေးက ရှင်းပါတယ်။ position ကို တစ်ခု လျော့လျော့ သွားပြီး postion 0 အောက် ရောက်သွားရင်တော့ hasNext() က false ပြန် ပါလိမ့်မယ်။

next() က list.get(postion) ကို return ပြန်ပေးပြီး postion-- နဲ့ position ကို တစ်ခု ပြန်လျော့ ထားပါတယ်။

public class Application {


    public static void main(String[] args) {

        ArrayList<String> col1 = new ArrayList<>();
        col1.add("a");
        col1.add("b");
        col1.add("c");

        ReverseArrayIterator revIterator = new ReverseArrayIterator(col1);
        while (revIterator.hasNext()) {
            System.out.println(revIterator.next());
        }


    }
}

ဒီ code မှာ ဆိုရင် c , b , a ဆိုပြီး ထွက်လာပါလိမ့်မယ်။

Pros and Cons

Single Responsibility ကို လိုက်နာထားပါတယ်။ Class က သူ့ ရဲ့ responsibility ပဲ ရှိပြီး iterator ကို သီးသန့် ခွဲထုတ်ထားပါတယ်။ iterator ကလည်း သူ့ရဲ့ single responsibility ပဲ ရှိပါတယ်။

Open/Closed Principle ကို လိုက်နာထားပါတယ်။ DFSIterator နဲ့ BFSIterator အပြင် အခြား tree အတွက် iterators တစ်ခု ထပ်ဖြည့်ချင်ရင် code အဟောင်းတွေကို ပြင်ဖို့ မလိုပါဘူး။

မကောင်းတာကတော့ over kill ဖြစ်နိုင်တယ်။ ပုံမှန် ရိုးရှင်း သည့် looping တွေမှာ မသုံးသင့်ပါဘူး။