java中的迭代器模式怎么實現

小編給大家分享一下java中的迭代器模式怎么實現，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

迭代器模式

迭代器模式用于順序訪問集合對象的元素，而不需要知道集合對象的底層表示。Java和.Net等語言已經將迭代器作為其內部語法元素，比如在C#中，集合對象只需要實現IEnumberable接口，然后就可以用foreach來遍歷了。 迭代器模式提示我們要從使用者的角度考慮如何設計接口，如何對外提供訪問內部對象的方式。即便我們組織的對象系統內部結構很復雜，但對于客戶程序而言最簡單的方式莫過于通過for /foreach循環依次遍歷，至于遍歷過程中的次序、分類篩選等則由目標類型自己封裝。

GOF對迭代器模式描述為： Provide a way to access the elements of an aggregate objectsequentially without exposing its underlying representation. — Design Patterns : Elements of Reusable Object-Oriented Software

UML類圖：

代碼實現

//迭代器接口
public interface IIterator<T>
{
    T Next();
    bool HasNext();
}
//具體迭代器
public class ConcreteIterator<T> : IIterator<T>
{
    private ConcreteAggretate<T> Aggretate; //成員變量，關聯關系
    private int cursor = 0;
    public ConcreteIterator(ConcreteAggretate<T> agg)
    {
        this.Aggretate = agg;
    }
    public bool HasNext()
    {
        return !(cursor >= Aggretate.Size);
    }

    public T Next()
    {
        if (HasNext())
        {
            return Aggretate.GetELement(cursor++);
        }
        else
        {
            return default(T);
        }

    }
}
//聚合接口
public interface IAggretate<T>
{
    public void Add(T obj);
    public void Remove(T obj);
    public int Size { get; }
    public T GetELement(int index);
    public IIterator<T> GetIterator();
}
//具體聚合
public class ConcreteAggretate<T> : IAggretate<T>
{
    private List<T> list = new List<T>();  //
    public void Add(T obj)
    {
        list.Add(obj);
    }

    public void Remove(T obj)
    {
        list.Remove(obj);
    }

    public IIterator<T> GetIterator()
    {
        return new ConcreteIterator<T>(this);  //在局部方法中new實例，屬依賴關系
    }

    public int Size
    {
        get
        {
            return list.Count;
        }
    }

    public T GetELement(int index)
    {
        return list[index];
    }
}

調用者代碼：

IAggretate<int> aggretate = new ConcreteAggretate<int>();
aggretate.Add(9);
aggretate.Add(8);
aggretate.Add(7);
IIterator<int> iterator = aggretate.GetIterator();
while (iterator.HasNext())
{
    Console.WriteLine(iterator.Next());
}

基于IEnumerable的實現

以上便是經典的迭代器模式的實現，這種模式給聚合對象增加了一個創建其迭代器對象的方法，迭代器的抽象定義和具體迭代器類型都作為一個額外的對象存在。 實際上C#已內置了對迭代器模式的支持，只需要實現IEnumerable接口即可，不再需要從0開始，少了很多代碼量：

public class ConcreteAggretate<T> : IEnumerable<T>
{
    private List<T> list = new List<T>();
    public void Add(T obj)
    {
        list.Add(obj);
    }

    public void Remove(T obj)
    {
        list.Remove(obj);
    }

    public IEnumerator<T> GetEnumerator()
    {
        foreach (var item in list)
        {
            yield return item;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new NotImplementedException();
    }
}

使用foreach遍歷IEnumerable接口

var aggretate = ConcreteAggretate<int>();
aggretate.Add(9);
aggretate.Add(8);
aggretate.Add(7);

foreach (var item in aggretate)
{
    Console.WriteLine(item);
}

使用場景

• 對象內部結構比較復雜，為了讓調用者可以輕松地訪問，同時不需要暴露其內部結構；

• 需要為聚合對象提供多種遍歷方式；

• 為遍歷不同的聚合結構提供一個統一的接口；

迭代器模式的優缺點

優點

• 迭代器支持以不同的方式遍歷一個聚合對象，而且在同一個聚合上可以添加多個具有不同遍歷方式的迭代器；

• 迭代器簡化了聚合類的遍歷；

• 迭代器模式可以方便地增加新的聚合類和迭代器類，無須修改原有代碼。

缺點 迭代器模式通過將存儲數據和遍歷數據的職責分離，為封裝集合地復雜性、隔離變化提供了極大的遍歷，但這種方式也有其固有的缺點：每次 增加新的聚合類都需要對應增加新的迭代器類，類的個數成對增加，這在一定程度上增加了系統的復雜性。

以上是“java中的迭代器模式怎么實現”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！