Iterator - wzorzec projektowy (design pattern)

I. Wzorce kreacyjne
1. Singleton
2. Budowniczy
3. Prototyp
4. Fabryka
5. Fabryka abstrakcyjna
II. Wzorce strukturalne
1. Adapter
2. Most
3. Kompozyt
4. Dekorator
5. Fasada
6. Pyłek
7. Pełnomocnik
III. Wzorce czynnościowe
1. Łańcuch zobowiązań
2. Polecenie
3. Interpreter
4. Iterator
5. Mediator
6. Pamiątka
7. Obserwator
8. Stan
9. Strategia
10. Metoda szablonowa
11. Odwiedzający

Iterator - wzorzec projektowy (design pattern) - java

1. Cel:
Wzorzec iterator jest świetnym wzorcem do zapewnienia nawigacji
bez eksponowania struktury obiektu.Upraszcza i ukrywa algorytm.
2. Problem:
Chcemy przejść przez kontener, taki jak kolekcje (Collection).
Lists, Map, Set są przykładami kolekcji.
Poruszanie się po różnych strukturach może mieć różne algorytmy
lub podejścia do przeglądania danych.

3. Rozwiązanie:
A przypadku wzorca iterator nie ujawniamy podstawowej struktury obiektu
po którym chcemy się poruszać.
Iterator oddziela dane z algorytmu użytego do przejścia przez dane.
Podstawą wzorca jest interface Iterator oraz implementacja konkretnego iteratora
Pętla foreach iteruje po interface-ie Iterable lub tablicy,
więc możemy interface Iterator tutaj zastosować.

4. Diagram klas wzorca Iterator:

5. Implementacja:
Klasa testująca:

public class IteratorTest {
    public static void main(String[] args) {
        ChannelCollection channels = populateChannels();
        ChannelIterator baseIterator = channels.iterator(ChannelTypeEnum.ALL);
        System.out.println("Kanały wszystkie:");
        while (baseIterator.hasNext()) {
            Channel c = baseIterator.next();
            System.out.println(c.toString());
        }
        System.out.println("Kanały polskie:");
        // Channel Type Iterator
        ChannelIterator englishIterator = channels.iterator(ChannelTypeEnum.POLISH);
        while (englishIterator.hasNext()) {
            Channel c = englishIterator.next();
            System.out.println(c.toString());
        }
    }
 
    private static ChannelCollection populateChannels() {
        ChannelCollection channels = new ChannelCollectionImpl();
        channels.addChannel(new Channel(98.5, ChannelTypeEnum.ENGLISH));
        channels.addChannel(new Channel(99.5, ChannelTypeEnum.POLISH));
        channels.addChannel(new Channel(100.5, ChannelTypeEnum.FRENCH));
        channels.addChannel(new Channel(101.5, ChannelTypeEnum.ENGLISH));
        channels.addChannel(new Channel(102.5, ChannelTypeEnum.POLISH));
        channels.addChannel(new Channel(103.5, ChannelTypeEnum.FRENCH));
        channels.addChannel(new Channel(104.5, ChannelTypeEnum.ENGLISH));
        channels.addChannel(new Channel(105.5, ChannelTypeEnum.POLISH));
        channels.addChannel(new Channel(106.5, ChannelTypeEnum.FRENCH));
        return channels;
    }
}

Klasy obsługujące wzorzec iterator:

public class Channel {
 
    private double frequency;
    private ChannelTypeEnum TYPE;
 
    public Channel(double freq, ChannelTypeEnum type){
        this.frequency=freq;
        this.TYPE=type;
    }
 
    public double getFrequency() {
        return frequency;
    }
 
    public ChannelTypeEnum getTYPE() {
        return TYPE;
    }
 
    @Override
    public String toString(){
        return "Frequency="+this.frequency+", Type="+this.TYPE;
    }
 
}
 
public enum ChannelTypeEnum {
 
    ENGLISH, FRENCH, POLISH, ALL;
}

interface-y i implementacja iteratora:

public interface ChannelIterator {
    boolean hasNext();
    Channel next();
}
 
public interface ChannelCollection {
 
    void addChannel(Channel c);
    void removeChannel(Channel c);
    ChannelIterator iterator(ChannelTypeEnum type);
 
}
 
public class ChannelCollectionImpl implements ChannelCollection {
 
    private List<Channel> channelsList;
 
    public ChannelCollectionImpl() {
        channelsList = new ArrayList<>();
    }
 
    public void addChannel(Channel c) {
        this.channelsList.add(c);
    }
 
    public void removeChannel(Channel c) {
        this.channelsList.remove(c);
    }
 
    @Override
    public ChannelIterator iterator(ChannelTypeEnum type) {
        return new ChannelIteratorImpl(type, this.channelsList);
    }
 
    private class ChannelIteratorImpl implements ChannelIterator {
 
        private ChannelTypeEnum type;
        private List<Channel> channels;
        private int position;
 
        public ChannelIteratorImpl(ChannelTypeEnum ty,
                                   List<Channel> channelsList) {
            this.type = ty;
            this.channels = channelsList;
        }
 
        @Override
        public boolean hasNext() {
            while (position < channels.size()) {
                Channel c = channels.get(position);
                if (c.getTYPE().equals(type) || type.equals(ChannelTypeEnum.ALL)) {
                    return true;
                } else
                    position++;
            }
            return false;
        }
 
        @Override
        public Channel next() {
            Channel c = channels.get(position);
            position++;
            return c;
        }
 
    }
}

Wynik programu jest następujący:
Kanały wszystkie:
Frequency=98.5, Type=ENGLISH
Frequency=99.5, Type=POLISH
Frequency=100.5, Type=FRENCH
Frequency=101.5, Type=ENGLISH
Frequency=102.5, Type=POLISH
Frequency=103.5, Type=FRENCH
Frequency=104.5, Type=ENGLISH
Frequency=105.5, Type=POLISH
Frequency=106.5, Type=FRENCH
Kanały polskie:
Frequency=99.5, Type=POLISH
Frequency=102.5, Type=POLISH
Frequency=105.5, Type=POLISH
6. Zastosowanie w kodzie java:
- java.util.Iterator
- java.util.Scanner
- java.util.Enumeration