设计模式：Iterator--迭代器模式

迭代器模式

顾名思义，迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。我们看下关系图：

 

MyCollection中定义了集合的一些操作，MyIterator中定义了一系列迭代操作，且持有Collection实例，

iterator迭代模式，行为模式之一，他把容器包含的内部对象的访问委让给外部类，使用Iteartor（遍历）    按顺序进行遍历访问的设计模式

优点：1实现功能分离，简化容器接口，让容器只实现本身基本功能，把迭代功能委让给外部实现，符合类的设计原则

2 隐藏容器的具体实现细节
3 为容器或子容器提供一个统一的接口，一方面方便调用，另一方面使得调用者不必关注迭代具体实现
4 可以为容器或子容器实现不同的迭代方法或多个迭代方法
 

实例一：

public class Book {
    private String ISBN;
    private String name;
    private double price;


    public Book(String ISBN, String name, double price) {
        this.ISBN = ISBN;
        this.name = name;
        this.price = price;
    }

    public String getISBN() {
        return ISBN;
    }

    public void setISBN(String ISBN) {
        this.ISBN = ISBN;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public void dispaly(){
        System.out.println("ISBN="+ISBN+ ",name="+name+",price="+price);
    }

    @Override
    public String toString() {
        return "Book{" +
                "ISBN='" + ISBN + '\'' +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

public class BookList {

    private List<Book> bookList;
    private int index;

    public BookList() {
        bookList = new ArrayList<>();
    }

    //添加书籍
    public void addBook(Book book) {
        bookList.add(book);
    }

    //删除书籍
    public void  remoceBook(Book book) {
        int index = bookList.indexOf(book);
        bookList.remove(index);
    }

   /* //判断
    public boolean hasNext(){
        if(index >= bookList.size()) {
            return false;
        }
        return true;
    }

    //获取
    public Book getNext(){
        return bookList.get(index++);
    }


    public List<Book> getBookList() {
        return bookList;
    }*/


    /**
     * 提供获取一个迭代器
     * @return
     */
    public Iterator iterator() {
        return new Itr();
    }

    //内部类封装Iterator  迭代器模式  ，可以写不同的内部类，实现多个不同的迭代细节
    private class Itr implements  Iterator {
        @Override
        public boolean hasNext() {
            if(index >= bookList.size()) {
                return false;
            }
            return true;
        }

        @Override
        public Object next() {
            return bookList.get(index++);
        }

        @Override
        public void remove() {

        }
    }


}

测试：

    public static void main(String[] args) {
        BookList bookList = new BookList();
        Book b = new Book("010203","java从入门熬精通",90);
        Book b1 = new Book("010204","java虚拟机",70);

        bookList.addBook(b);
        bookList.addBook(b1);
        //没用iterator模式：:方式一：让容器自己实现iterator顺序遍历
//        while(bookList.hasNext()) {
//            Book next = bookList.getNext();
//           next.dispaly();
//        }

        System.out.println("***********************");

        //没用iterator模式：方式二让调用者自己实现遍历
//        List<Book> bookList1 = bookList.getBookList();
//        for(Book book : bookList1){
//            book.dispaly();
//        }

        Iterator iterator = bookList.iterator();
        while(iterator.hasNext()) {
            Book next = (Book)iterator.next();
            next.dispaly();
        }


    }


测试结果：
***********************
ISBN=010203,name=java从入门熬精通,price=90.0
ISBN=010204,name=java虚拟机,price=70.0

代码实现二：

public interface Collection {

    public Iterator iterator();

    /*取得集合元素*/
    public Object get(int i);

    /*取得集合大小*/
    public int size();

}


**********************************************************

public interface Iterator {

    //前移
    public Object previous();

    //后移
    public Object next();

    //判断是否含有下一个
    public boolean hasNext();

    //取得第一个元素
    public Object first();

}


**********************************************************

public class MyCollection implements Collection {

    public String string[] = {"A","B","C","D","E"};
//    String arr[] = new String[5];
//    String arrr[] = new String[]{"A","B","C","D","E"};

    @Override
    public Iterator iterator() {
        return new MyIterator(this);
    }

    @Override
    public Object get(int i) {
        return string[i];
    }

    @Override
    public int size() {
        return string.length;
    }
}


**********************************************************



public class MyIterator implements Iterator {

    private Collection collection;
    private int index = -1;

    public MyIterator(Collection collection) {
        this.collection = collection;
    }

    @Override
    public Object previous() {
        if(index  > 0){
            index--;
        }
        return collection.get(index);
    }

    @Override
    public Object next() {
        if(index < collection.size()-1){
            index++;
        }
        return collection.get(index);
    }

    @Override
    public boolean hasNext() {
        if(index<collection.size()-1){
            return true;
        }else{
            return false;
        }
    }

    @Override
    public Object first() {
        index = 0;
        return collection.get(index);
    }
}
    

**********************************************************

 public static void main(String[] args) {
        Collection collection = new MyCollection();
        Iterator iterator = collection.iterator();
        while(iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }


**********************************************************


测试结果：
A
B
C
D
E


**********************************************************

三、事例3

Department 院系

/**
 * @auhtor
 * @create 2023-02-07-14:37
 * 院系
 */
@Data
public class Department {

    private String name;

    private String desc;

    public Department(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
}

统一的对象 

public interface College {
    /**获取名称*/
    String getName();
    /**添加系*/
    void addDepartment(String name, String desc);
    /**获取迭代器*/
    Iterator createIterator();
}

ComputerCollege 计算机学院 

public class ComputerCollege implements College{

    private Department[] departments;
    int numOfDepartmetn = 0; // 保存当前数组的对象个数

    public ComputerCollege() {
        departments = new Department[5];
        addDepartment("Java专业","java");
        addDepartment("PHP专业","php");
        addDepartment("大数据专业","大数据");
    }

    @Override
    public String getName() {
        return "计算机学院";
    }

    @Override
    public void addDepartment(String name, String desc) {
        Department department = new Department(name, desc);
        departments[numOfDepartmetn] = department;
        numOfDepartmetn++;
    }

    @Override
    public Iterator createIterator() {
        return new ComputerIterator(departments);
    }
}

计算机学院的迭代器：遍历ComputerColege里面所有属性的迭代器 ComputerIterator 

public class ComputerIterator<E> implements Iterator {
    private E[] departments;
    int position = 0;

    public ComputerIterator(E[] departments) {
        this.departments = departments;
    }

    @Override
    public boolean hasNext() {
        if (position > departments.length || departments[position] == null) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public Object next() {
        E department = departments[position];
        position++;
        return department;
    }

    @Override
    public void remove() {

    }
}

信息工程学院 InfoCollege  

public class InfoCollege implements College {
    private List<Department> departments;

    public InfoCollege() {
        departments = new ArrayList<>();
        addDepartment("信息安全专业", "信息安全");
        addDepartment("网络安全专业", "网络安全");
        addDepartment("服务器安全专业", "服务器安全");
    }

    @Override
    public String getName() {
        return "信息工程学院";
    }

    @Override
    public void addDepartment(String name, String desc) {
        departments.add(new Department(name,desc));
    }

    @Override
    public Iterator createIterator() {
        return new InfoCollegeIterator(departments);
    }
}

信息工程学院的迭代器InfoCollegeIterator

public class InfoCollegeIterator<E> implements Iterator {
    // 信息工程以集合List形式存放系
    private List<E> departments;
    int index = 0;

    public InfoCollegeIterator(List<E> departments) {
        this.departments = departments;
    }

    @Override
    public boolean hasNext() {
        if (index >= departments.size()) {
            return false;
        }
        return true;
    }

    @Override
    public Object next() {
        E e = departments.get(index);
        index++;
        return e;
    }

    @Override
    public void remove() {

    }
}

输出main方法

public class OutputImpl {
    private List<College> colleges;

    public OutputImpl(List<College> colleges) {
        this.colleges = colleges;
    }

    public void printCollege() {
        // 遍历
        Iterator<College> iterator = colleges.iterator();
        while (iterator.hasNext()) {
            // 取出学院
            College next = iterator.next();
            System.out.println("==" + next.getName() + "==");
            printDepartment(next.createIterator());

        }
    }

    public void printDepartment(Iterator iterator) {
        while (iterator.hasNext()) {
            Department next = (Department) iterator.next();
            System.out.println(next.getName());
        }
    }
}

public class MainClient {
    public static void main(String[] args) {
        // 创建学院
        List<College> list = new ArrayList();
        College computerCollege = new ComputerCollege();
        College infoCollege = new InfoCollege();

        list.add(computerCollege);
        list.add(infoCollege);
        OutputImpl output = new OutputImpl(list);
        output.printCollege();

        
    }
}
// console 输出
==计算机学院==
Java专业
PHP专业
大数据专业
==信息工程学院==
信息安全专业
网络安全专业
服务器安全专业