Java学习者论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

手机号码,快捷登录

恭喜Java学习者论坛(https://www.javaxxz.com)已经为数万Java学习者服务超过8年了!积累会员资料超过10000G+
成为本站VIP会员,下载本站10000G+会员资源,购买链接:点击进入购买VIP会员
JAVA高级面试进阶视频教程Java架构师系统进阶VIP课程

分布式高可用全栈开发微服务教程

Go语言视频零基础入门到精通

Java架构师3期(课件+源码)

Java开发全终端实战租房项目视频教程

SpringBoot2.X入门到高级使用教程

大数据培训第六期全套视频教程

深度学习(CNN RNN GAN)算法原理

Java亿级流量电商系统视频教程

互联网架构师视频教程

年薪50万Spark2.0从入门到精通

年薪50万!人工智能学习路线教程

年薪50万!大数据从入门到精通学习路线年薪50万!机器学习入门到精通视频教程
仿小米商城类app和小程序视频教程深度学习数据分析基础到实战最新黑马javaEE2.1就业课程从 0到JVM实战高手教程 MySQL入门到精通教程
查看: 425|回复: 0

[设计模式学习]java中设计与使用迭代器

[复制链接]
  • TA的每日心情
    开心
    2021-3-12 23:18
  • 签到天数: 2 天

    [LV.1]初来乍到

    发表于 2014-11-4 00:01:16 | 显示全部楼层 |阅读模式
    1.迭代器设计
          

       
        迭代器是一种模式,它可以使得对于序列类型的数据结构的遍历行为与被遍历的对象分离,即我们无需关心该序列的底层结构是什么样子的。
       
       
        一般的迭代器对外提供的接口有:
       
       
        [1]
        检查是否至序列末端;
       
       
        [2]
        返回当前的对象;
       
       
        [3]
        过渡到下一个对象。
       
       
        我们基于以上三点,提供一个迭代器
        Interface
        。
       
       
       
    MyIterator.java
          

       
       
         
          
          
          
            package
             com.zj.iterator;
             
             
            
          
             
             
            
          
            public
             
            interface
             MyIterator<T> {
             
             
            
          
                
            boolean
             end();
             
             
            
          
                T current();
             
             
            
          
                
            void
             next();
             
             
            
          
            }
            
          
         
       
       
        接下来,设计一个序列,并部署上面设计的迭代器。我们使用一个
        ArrayList
        作为底层的数据结构,设计一个内部类
        LinksIterator
        来实现
        MyIterator
        接口,这样可以提供迭代器功能。通过
        public
         MyIterator<T> browser()
        方法返回该迭代器的实例。
       

       

       
       
        Links.java
          

       
       
         
          
          
          
            package
             com.zj.iterator;
             
             
            
          
            import
             java.util.ArrayList;
             
             
            
          
            import
             java.util.List;
             
             
            
          
             
             
            
          
            public
             
            class
             Links<T> {
             
             
            
          
                
            private
             List<T>
            items
             =
            new
             ArrayList<T>();
             
             
            
          
             
             
            
          
                
            public
             
            void
             add(T x) {
             
             
            
          
                   
            items
            .add(x);
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            private
             
            class
             LinksIterator
            implements
             MyIterator<T> {
             
             
            
          
                   
            private
             
            int
             
            i
             = 0;
             
             
            
          
             
             
            
          
                   
            public
             
            boolean
             end() {
             
             
            
          
                      
            return
             
            i
             ==
            items
            .size();
             
             
            
          
                   }
             
             
            
          
             
             
            
          
                   
            public
             T current() {
             
             
            
          
                      
            return
             
            items
            .get(
            i
            );
             
             
            
          
                   }
             
             
            
          
             
             
            
          
                   
            public
             
            void
             next() {
             
             
            
          
                      
            if
             (
            i
             <
            items
            .size())
             
             
            
          
                         
            i
            ++;
             
             
            
          
                   }
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             MyIterator<T> browser() {
             
             
            
          
                   
            return
             
            new
             LinksIterator();
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             
            static
             
            void
             main(String[] args) {
             
             
            
          
                   Links<Integer> links =
            new
             Links<Integer>();
             
             
            
          
                   
            for
             (
            int
             i = 1; i < 6; i++)
             
             
            
          
                       links.add(i);
             
             
            
          
                   
            // use MyIterator
             
             
            
          
                   MyIterator<Integer> myItr = links.browser();
             
             
            
          
                   
            while
             (!myItr.end()) {
             
             
            
          
                       System.
            out
            .print(myItr.current() +
            " "
            );
             
             
            
          
                       myItr.next();
             
             
            
          
                   }
             
             
            
          
                }
             
             
            
          
            }
            
          
         
       
       
        在
        Link2.java
        中,我们使用一个匿名内部类替代
        Links.java
        中内部类的设计。
       
       
        Links2.java
          

       
       
         
          
          
          
            package
             com.zj.iterator;
             
             
            
          
            import
             java.util.ArrayList;
             
             
            
          
            import
             java.util.List;
             
             
            
          
             
             
            
          
            public
             
            class
             Links2<T> {
             
             
            
          
                
            private
             List<T>
            items
             =
            new
             ArrayList<T>();
             
             
            
          
             
             
            
          
                
            public
             
            void
             add(T x) {
             
             
            
          
                   
            items
            .add(x);
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             MyIterator<T> browser() {
             
             
            
          
                   
            return
             
            new
             MyIterator<T>() {
             
             
            
          
                      
            private
             
            int
             
            i
             = 0;
             
             
            
          
             
             
            
          
                      
            public
             
            boolean
             end() {
             
             
            
          
                         
            return
             
            i
             ==
            items
            .size();
             
             
            
          
                       }
             
             
            
          
             
             
            
          
                      
            public
             T current() {
             
             
            
          
                         
            return
             
            items
            .get(
            i
            );
             
             
            
          
                       }
             
             
            
          
             
             
            
          
                      
            public
             
            void
             next() {
             
             
            
          
                         
            if
             (
            i
             <
            items
            .size())
             
             
            
          
                              
            i
            ++;
             
             
            
          
                       }
             
             
            
          
                   };
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             
            static
             
            void
             main(String[] args) {
             
             
            
          
                   Links2<Integer> links =
            new
             Links2<Integer>();
             
             
            
          
                   
            for
             (
            int
             i = 1; i < 6; i++)
             
             
            
          
                       links.add(i);
             
             
            
          
                   
            // use MyIterator
             
             
            
          
                   MyIterator<Integer> myItr = links.browser();
             
             
            
          
                   
            while
             (!myItr.end()) {
             
             
            
          
                       System.
            out
            .print(myItr.current() +
            " "
            );
             
             
            
          
                       myItr.next();
             
             
            
          
                   }
             
             
            
          
                }
             
             
            
          
            }
            
          
         
       
       
        2.
        使用
        Java
        提供的迭代器
       
          

       
       
        Java
        提供一个专门的迭代器
        <<interface>>Iterator
        ,我们可以对某个序列实现该
        interface
        ,来提供标准的
        Java
        迭代器。
       
       
        <<interface>>Iterator.java
          

       
       
         
          
          
          
            package
             java.util;
             
             
            
          
             
             
            
          
            public
             
            interface
             Iterator<E> {
             
             
            
          
                
            boolean
             hasNext();
             
             
            
          
                E next();
             
             
            
          
                
            void
             remove();
             
             
            
          
            }
            
          
         
       
       
        我们在
        Links2.java
        的基础上,重新设计并使用实现标准的
        Iterator
        接口方法。
       
       
        Links3.java
          

       
       
         
          
          
          
            package
             com.zj.iterator.standard;
             
             
            
          
             
             
            
          
            import
             java.util.ArrayList;
             
             
            
          
            import
             java.util.Iterator;
             
             
            
          
            import
             java.util.List;
             
             
            
          
             
             
            
          
            public
             
            class
             Links3<T> {
             
             
            
          
                
            private
             List<T>
            items
             =
            new
             ArrayList<T>();
             
             
            
          
             
             
            
          
                
            public
             
            void
             add(T x) {
             
             
            
          
                   
            items
            .add(x);
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             Iterator<T> iterator() {
             
             
            
          
                   
            return
             
            new
             Iterator<T>() {
             
             
            
          
                      
            private
             
            int
             
            index
             = 0;
             
             
            
          
             
             
            
          
                      
            public
             
            boolean
             hasNext() {
             
             
            
          
                         
            return
             
            index
             <
            items
            .size();
             
             
            
          
                       }
             
             
            
          
             
             
            
          
                      
            public
             T next() {
             
             
            
          
                         
            return
             
            items
            .get(
            index
            ++);
             
             
            
          
                       }
             
             
            
          
             
             
            
          
                      
            public
             
            void
             remove() {
            // Not implemented
             
             
            
          
                         
            throw
             
            new
             UnsupportedOperationException();
             
             
            
          
                       }
             
             
            
          
                   };
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             
            static
             
            void
             main(String[] args) {
             
             
            
          
                   Links3<Integer> links =
            new
             Links3<Integer>();
             
             
            
          
                   
            for
             (
            int
             i = 1; i < 6; i++)
             
             
            
          
                       links.add(i);
             
             
            
          
                   
            // use Standard Iterator
             
             
            
          
                   Iterator<Integer> myItr = links.iterator();
             
             
            
          
                   
            while
             (myItr.hasNext())
             
             
            
          
                       System.
            out
            .print(myItr.next() +
            " "
            );
             
             
            
          
                }
             
             
            
          
            }
            
          
         
       
       
        3.Java
        迭代器与
        Foreach
        语法
       
          

       
       
        Java
        中还提供了一个
        Iterable
        接口,该接口要求提供一个标准的
        Iterator
        实现。
       

       

       
       
        <<interface>>
        Iterable.java
          

       
       
         
          
          
          
            package
             java.lang;
             
             
            
          
             
             
            
          
            import
             java.util.Iterator;
             
            
          
            public
             
            interface
             Iterable<T> {
             
             
            
          
                Iterator<T> iterator();
             
             
            
          
            }
            
          
         
       
       
        只要实现了该接口,就可以通过
        Foreach
        语法遍历你的底层序列。
        Links4.java
        实现了
        Iterable
        接口,则就可以使用
        Foreach
        语法遍历它的底层序列。
       

       

       
       
        Links4.java
          

       
       
         
          
          
          
            package
             com.zj.iterator.standard;
             
             
            
          
            import
             java.util.ArrayList;
             
             
            
          
            import
             java.util.Iterator;
             
             
            
          
            import
             java.util.List;
             
             
            
          
             
             
            
          
            public
             
            class
             Links4<T>
            implements
             Iterable<T> {
             
             
            
          
                
            private
             List<T>
            items
             =
            new
             ArrayList<T>();
             
             
            
          
             
             
            
          
                
            public
             
            void
             add(T x) {
             
             
            
          
                   
            items
            .add(x);
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             Iterator<T> iterator() {
             
             
            
          
                   
            return
             
            new
             Iterator<T>() {
             
             
            
          
                      
            private
             
            int
             
            index
             = 0;
             
             
            
          
             
             
            
          
                      
            public
             
            boolean
             hasNext() {
             
             
            
          
                         
            return
             
            index
             <
            items
            .size();
             
             
            
          
                       }
             
             
            
          
             
             
            
          
                      
            public
             T next() {
             
             
            
          
                         
            return
             
            items
            .get(
            index
            ++);
             
             
            
          
                       }
             
             
            
          
             
             
            
          
                      
            public
             
            void
             remove() {
            // Not implemented
             
             
            
          
                         
            throw
             
            new
             UnsupportedOperationException();
             
             
            
          
                       }
             
             
            
          
                   };
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             
            static
             
            void
             main(String[] args) {
             
             
            
          
                   Links4<Integer> links =
            new
             Links4<Integer>();
             
             
            
          
                   
            for
             (
            int
             i = 1; i < 6; i++)
             
             
            
          
                       links.add(i);
             
             
            
          
                   
            // use Foreach
             
             
            
          
                   
            for
             (Integer integer : links)
             
             
            
          
                       System.
            out
            .print(integer +
            " "
            );
             
             
            
          
                }
             
             
            
          
            }
            
          
         
       
       
        你也可以提供该接口的多个不同的实现,基于此来提供多个不同功能的迭代器。
        Links5.java
        中提供了两种不同功能的迭代器,除了常规的顺序遍历迭代器外,还提供一个遍历偶序号元素的迭代器。
       
       
        Links5.java
          

       
       
         
          
          
          
            package
             com.zj.iterator.standard;
             
             
            
          
             
             
            
          
            import
             java.util.ArrayList;
             
             
            
          
            import
             java.util.Iterator;
             
             
            
          
            import
             java.util.List;
             
             
            
          
             
             
            
          
            public
             
            class
             Links5<T>
            implements
             Iterable<T> {
             
             
            
          
                
            private
             List<T>
            items
             =
            new
             ArrayList<T>();
             
             
            
          
             
             
            
          
                
            public
             
            void
             add(T x) {
             
             
            
          
                   
            items
            .add(x);
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             Iterator<T> iterator() {
             
             
            
          
                   
            return
             
            new
             Iterator<T>() {
             
             
            
          
                      
            private
             
            int
             
            index
             = 0;
             
             
            
          
             
             
            
          
                      
            public
             
            boolean
             hasNext() {
             
             
            
          
                         
            return
             
            index
             <
            items
            .size();
             
             
            
          
                       }
             
             
            
          
             
             
            
          
                      
            public
             T next() {
             
             
            
          
                         
            return
             
            items
            .get(
            index
            ++);
             
             
            
          
                       }
             
             
            
          
             
             
            
          
                      
            public
             
            void
             remove() {
            // Not implemented
             
             
            
          
                         
            throw
             
            new
             UnsupportedOperationException();
             
             
            
          
                       }
             
             
            
          
                   };
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             Iterable<T> even() {
             
             
            
          
                   
            return
             
            new
             Iterable<T>() {
             
             
            
          
                      
            public
             Iterator<T> iterator() {
             
             
            
          
                         
            return
             
            new
             Iterator<T>() {
             
             
            
          
                              
            private
             
            int
             
            index
             = 0;
             
             
            
          
             
             
            
          
                              
            public
             
            boolean
             hasNext() {
             
             
            
          
                                 
            return
             
            index
             <
            items
            .size();
             
             
            
          
                              }
             
             
            
          
             
             
            
          
                              
            public
             T next() {
             
             
            
          
                                 
            index
             += 2;
             
             
            
          
                                 
            return
             
            items
            .get(
            index
             - 2);
             
             
            
          
                              }
             
             
            
          
             
             
            
          
                              
            public
             
            void
             remove() {
            // Not implemented
             
             
            
          
                                 
            throw
             
            new
             UnsupportedOperationException();
             
             
            
          
                              }
             
             
            
          
                          };
             
             
            
          
                       }
             
             
            
          
                   };
             
             
            
          
                }
             
             
            
          
             
             
            
          
                
            public
             
            static
             
            void
             main(String[] args) {
             
             
            
          
                   Links5<Integer> links =
            new
             Links5<Integer>();
             
             
            
          
                   
            for
             (
            int
             i = 1; i < 6; i++)
             
             
            
          
                       links.add(i);
             
             
            
          
                   
            // use Foreach default
             
             
            
          
                   
            for
             (Integer integer : links)
             
             
            
          
                       System.
            out
            .print(integer +
            " "
            );
             
             
            
          
                   System.
            out
            .println();
             
             
            
          
                   
            // use Foreach even
             
             
            
          
                   
            for
             (Integer integer : links.even())
             
             
            
          
                       System.
            out
            .print(integer +
            " "
            );
             
             
            
          
                }
             
             
            
          
            }
            
          
         
       

       
         
         
          
          

            
          

            
          
         
       

      


    源码下载:http://file.javaxxz.com/2014/11/4/000115687.zip
    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则

    QQ|手机版|Java学习者论坛 ( 声明:本站资料整理自互联网,用于Java学习者交流学习使用,对资料版权不负任何法律责任,若有侵权请及时联系客服屏蔽删除 )

    GMT+8, 2025-2-25 13:05 , Processed in 0.401370 second(s), 48 queries .

    Powered by Discuz! X3.4

    © 2001-2017 Comsenz Inc.

    快速回复 返回顶部 返回列表