夢幻之旅
          
				
          DEBUG - 天道酬勤
          
			          		
		
          
	
          

          

          
	
          
		
          
			
 
 ::
首頁 ::
新隨筆 ::
聯系 ::
聚合
 ::
管理 ::


			
			
				

          
	
          
		
          
			
			
			
				 
				671 
				隨筆 ::
				6 文章
				::
				256 評論
				::
				0 Trackbacks
			
		
          
	
          

          

			          		
		
          
	
          

          


          


          
	
					

          
	
	
	
          
		
          迭代器模式,又叫游標模式.
          

          提供一種方法訪問一個容器（container）對象中各個元素，而又不需暴露該對象的內部細節。
          在迭代器模式中，具體迭代器角色和具體容器角色是耦合在一起的 —— 遍歷算法是與容器的內部細節緊密相關的。為了使客戶程序從與具體迭代器角色耦合的困境中脫離出來，避免具體迭代器角色的更換給客戶程序帶來的修改，迭代器模式抽象了具體迭代器角色，使得客戶程序更具一般性和重用性。這被稱為多態迭代
          迭代器模式的組成部份
          1.集合,一個接口,規定了具體集合需要實現的操作.
          2.具體集合,是實現集合接口的實例,具體集合按著一定的結構存儲對象,具體集合應當有一個方法返回針對該集合的具體迭代器.
          3.迭代器, 一個接口,規定了遍歷集合的方法.
          4.具體迭代器
          迭代器各組成部份之間的關系

          例子:
          集合:
          

          package iterator;

          public interface Aggregate<E>
          {
                        public Iterator<E> createIterator();
              
                        public int length();
              
                        public E get(int index);
              
                        public void add(E obj);
          }
          

          具體集合:
          

          package iterator;

          import java.util.ArrayList;
          import java.util.List;

          public class ConcreteAggregate<E> implements Aggregate<E>
          {
                        private List<E> items = new ArrayList<E>();
              
                        public Iterator<E> createIterator()
                        {
                            return new ConcreteIterator<E>(this);
              }
              
                        public int length()
                        {
                            return items.size();
              }
              
                        public E get(int index)
                        {
                            return (E) items.get(index);
              }
              
                        public void add(E obj)
                        {
                  items.add(obj);
              }
              
          }
          



          迭代器:
          

           
          

          package iterator;

          public interface Iterator<E>
          {
                        public E first();
              
                        public boolean hasNext();
              
                        public E next();
              
                        public E current();
          }
          


          具體迭代器:
          

          package iterator;

          public class ConcreteIterator<E> implements Iterator<E>
          {
                        private Aggregate<E> aggregate;
              
                        private int currentIndex = 0;
              
                        public ConcreteIterator(Aggregate<E> aggregate)
                        {
                            this.aggregate = aggregate;
              }
              
                        public E first()
                        {
                  currentIndex           = 0;
                            if (hasNext())
                            {
                                return aggregate.get(currentIndex);
                  }
                            else
                            {
                                return null;
                  }
              }
              
                        public boolean hasNext()
                        {
                            return (currentIndex < aggregate.length());
              }
              
                        public E next()
                        {
                  currentIndex          ++;
                            if (hasNext())
                            {
                                return aggregate.get(currentIndex);
                  }
                            else
                            {
                                return null;
                  }
              }
              
                        public E current()
                        {
                            return aggregate.get(currentIndex);
              }
          }
          



          測試類:
          

          package iterator;

          public class Test
          {
                        public static void main(String[] args)
                        {
                  Aggregate          <String> a = new ConcreteAggregate<String>();
                  a.add(          "111");
                  a.add(          "222");
                  a.add(          "333");
                  
                  Iterator          <String> it = a.createIterator();
                            for (String s = it.first(); it.hasNext(); s = it.next())
                            {
                      System.out.println(s);
                  }
              }
              
          }
          

          迭代器的優點:
                1、支持以不同的方式遍歷一個容器角色。根據實現方式的不同，效果上會有差別。
                2、簡化了容器的接口。但是在java Collection中為了提高可擴展性，容器還是提供了遍歷的接口。
                3、對同一個容器對象，可以同時進行多個遍歷。因為遍歷狀態是保存在每一個迭代器對象中的。
           
	
          
	
	
          
		posted on 2011-08-01 13:29 HUIKK 閱讀(300) 評論(0)  編輯  收藏  所屬分類: Design Patterns 
	
          

          







          
	    
    




          








          

				

          




    







          
        
	




主站蜘蛛池模板：
宁陕县|
大安市|
台南市|
灵宝市|
海伦市|
和顺县|
青神县|
沐川县|
轮台县|
阿拉善右旗|
鹤山市|
山丹县|
岳池县|
河间市|
金平|
天门市|
达州市|
饶平县|
华坪县|
师宗县|
桃园市|
娄底市|
新宁县|
邹平县|
定结县|
浦东新区|
莱州市|
沽源县|
肃宁县|
阳西县|
汾西县|
宜君县|
泉州市|
左贡县|
建平县|
崇仁县|
怀集县|
新晃|
海原县|
静安区|
安徽省|