设计模式学习笔记——迭代器(Iterator)模式

雨点打透心脏的1/2处 2022-07-16 14:28 283阅读 0赞

# 设计模式学习笔记——迭代器(Iterator)模式 #

@(设计模式)\[设计模式, 迭代器模式, iterator, 迭代器\]

*  设计模式学习笔记迭代器Iterator模式
    
     *  基本介绍
     *  迭代器案例
        
         *  类图
         *  实现代码
            
             *  Aggregate接口
             *  Iterator接口
             *  Book类
             *  BookShelf类
             *  BookShelfIterator类
             *  测试类
             *  运行结果
     *  迭代器模式中的角色
        
         *  Iterator迭代器
         *  ConcreteIterator具体的迭代器
         *  Aggregate集合
         *  ConcreteAggregate具体的集合
         *  类图

## 基本介绍 ##

迭代器模式是从集合中取出元素进行遍历。

迭代器模式主要用于将数据的遍历访问与实现进行分离。

迭代器种类有很多，像是由前往后，由后往前，跳跃遍历等等。

## 迭代器案例 ##

### 类图 ###

![这里写图片描述][SouthEast]

### 实现代码 ###

#### Aggregate接口 ####

package com.pc.iterator.example;
    
    /** * 集合接口 * Created by switch on 17/1/18. */
    public interface Aggregate<T> { 
        /** * 返回迭代器 * * @return 迭代器对象 */
        Iterator<T> iterator();
    }

#### Iterator接口 ####

package com.pc.iterator.example;
    
    /** * 迭代器接口 * Created by switch on 17/1/18. */
    public interface Iterator<T> { 
        /** * 是否有下一个对象 * * @return true, 有;false,无 */
        boolean hasNext();
    
        /** * 获取下一个对象 * * @return 下一个对象 */
        T next();
    }

#### Book类 ####

package com.pc.iterator.example;
    
    /** * 书籍类 * Created by switch on 17/1/19. */
    public class Book { 
        private String name; // 书籍名称
    
        public Book() {
    
        }
    
        public Book(String name) {
            this.name = name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        @Override
        public String toString() {
            return "Book{" + "name='" + name + '\'' + '}';
        }
    }

#### BookShelf类 ####

package com.pc.iterator.example;
    
    /** * 书架类 * Created by switch on 17/1/19. */
    public class BookShelf implements Aggregate<Book> { 
        private Book[] books; // 书籍数组
    
        private int last = 0; // 书架上的书籍本书
    
        /** * 根据书籍本数，构建书架 * * @param bookSize 书籍本数 */
        public BookShelf(int bookSize) {
            books = new Book[bookSize];
        }
    
        /** * 根据索引获取书籍中的书籍 * * @param index 索引 * @return 索引对应的书籍 * @throws ArrayIndexOutOfBoundsException */
        public Book getBookAt(int index) throws ArrayIndexOutOfBoundsException {
            return books[index];
        }
    
        /** * 获取书架上的书籍本书 * * @return 书籍本书 */
        public int getLength() {
            return this.last;
        }
    
        /** * 添加书籍到书架末尾 * * @param book 书籍 */
        public void add(Book book) {
            books[last++] = book;
        }
    
        @Override
        public Iterator<Book> iterator() {
            return new BookShelfIterator(this);
        }
    }

#### BookShelfIterator类 ####

package com.pc.iterator.example;
    
    /** * 书架迭代器(正序遍历迭代器) * Created by switch on 17/1/19. */
    public class BookShelfIterator implements Iterator<Book> { 
        private BookShelf bookShelf; // 书架
    
        private int index = 0; // 当前遍历到的对象的索引
    
        /** * 根据书架对象创建书架迭代器对象 * * @param bookShelf 书架 */
        public BookShelfIterator(BookShelf bookShelf) {
            this.bookShelf = bookShelf;
        }
    
        @Override
        public boolean hasNext() {
            if (this.index >= bookShelf.getLength()) {
                return false;
            }
            return true;
        }
    
        @Override
        public Book next() {
            return bookShelf.getBookAt(index++);
        }
    }

#### 测试类 ####

package com.pc.iterator.example.test;
    
    import com.pc.iterator.example.Book;
    import com.pc.iterator.example.BookShelf;
    import com.pc.iterator.example.Iterator;
    import org.junit.Before;
    import org.junit.Test;
    
    /** * 书架迭代器测试 * Created by switch on 17/1/19. */
    public class BookShelfIteratorTest { 
        BookShelf bookShelf;
    
        /** * 初始化方法 */
        @Before
        public void init() {
            bookShelf = new BookShelf(20);
            // 添加一些书籍
            Book book1 = new Book("图解设计模式");
            Book book2 = new Book("Spring实战");
            Book book3 = new Book("设计模式");
            Book book4 = new Book("深入分析Java Web技术内幕");
            Book book5 = new Book("大型网站技术架构 核心原理与案例分析");
            Book book6 = new Book("情商");
            Book book7 = new Book("三体");
            Book book8 = new Book("银河帝国");
            Book book9 = new Book("神们自己");
            Book book10 = new Book("信息简史");
    
            bookShelf.add(book1);
            bookShelf.add(book2);
            bookShelf.add(book3);
            bookShelf.add(book4);
            bookShelf.add(book5);
            bookShelf.add(book6);
            bookShelf.add(book7);
            bookShelf.add(book8);
            bookShelf.add(book9);
            bookShelf.add(book10);
        }
    
    
        /** * 测试迭代器 */
        @Test
        public void testIterator() {
            Iterator<Book> iterator = bookShelf.iterator();
            while (iterator.hasNext()) {
                Book book = iterator.next();
                System.out.println(book);
            }
        }
    }

#### 运行结果 ####

Book{name='图解设计模式'}
    Book{name='Spring实战'}
    Book{name='设计模式'}
    Book{name='深入分析Java Web技术内幕'}
    Book{name='大型网站技术架构 核心原理与案例分析'}
    Book{name='情商'}
    Book{name='三体'}
    Book{name='银河帝国'}
    Book{name='神们自己'}
    Book{name='信息简史'}

## 迭代器模式中的角色 ##

### Iterator(迭代器) ###

该角色负责定义按顺序逐个遍历元素的接口(`API`)。在示例程序中，由`Iterator`接口扮演这个角色， 它定义了`hasNext`和`next`两个方法。其中，`hasNext`方法用于判断是否存在下一个元素， `next`方法则用于获取该元素。

### ConcreteIterator(具体的迭代器) ###

该角色负责实现`Iterator`角色所定义的接口(`API`)。在案例中，由`BookShelfIterator`类扮演这个角色。该角色中包含了遍历集合所必需的信息。在案例中，`Bookshelf`类的实例保存在`bookShelf`字段中， 被指向的书的下标保存在`index`字段中。

### Aggregate(集合) ###

该角色负责定义创建`Iterator`角色的接口(`API`)。这个接口(`API`)是一个方法， 返回`Iterator`类型。在案例中，由`Aggregate`接口扮演这个角色，它里面定义了`iterator`方法。

### ConcreteAggregate(具体的集合) ###

该角色负责实现`Aggregate`角色所定义的接口(`API`)。它会创建出具体的`Iterator`角色， 即`ConcreteIterator`角色。在案例中，由`BookShelf`类扮演这个角色， 它实现了`iterator`方法。

### 类图 ###

![这里写图片描述][SouthEast 1]

GitHub：[DesignPatternStudy][]

——————参考《图解设计模式》

[SouthEast]: /images/20220709/5eb25d01413d43b698eaf335f0ebe1ea.png
[SouthEast 1]: /images/20220709/689110a8633a484b832a949b872be0aa.png
[DesignPatternStudy]: https://github.com/Switch-vov/DesignPatternStudy