public class ComputerCollegeIterator implements Iterator {
    //以數(shù)組的方式存放計(jì)算機(jī)學(xué)院下面的各個(gè)系
    private Department[] departments;
    //當(dāng)前遍歷到的位置
    private  Integer position=0;
    //通過(guò)構(gòu)造器獲得要遍歷的集合
    public ComputerCollegeIterator(Department[] departments)
    {
        this.departments=departments;
    }
    //判斷是否還存在下一個(gè)元素
    @Override
    public boolean hasNext() {
        if(position>departments.length-1||departments[position]==null)
        {
            return false;
        }
        return true;
    }
    //返回下一個(gè)元素
    @Override
    public Object next() {
        return departments[position++];
    }
    //刪除的方法默認(rèn)空實(shí)現(xiàn)
    @Override
    public void remove()
    {}
}

//信息學(xué)院
public class InfoCollegeIterator implements Iterator
{
 //以list的方式存放系
    private List<Department> departments;
    //索引
    private  Integer index=0;
   //構(gòu)造器得到要遍歷的集合
    InfoCollegeIterator(List<Department> departments)
    {
        this.departments=departments;
    }
    //判斷l(xiāng)ist集合中是否還有下一個(gè)元素
    @Override
    public boolean hasNext() {
          if(index>departments.size()-1)
          {
              return false;
          }
          return true;
    }
    @Override
    public Object next() {
        return departments.get(index++);
    }
    @Override
    public void remove() {
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
//學(xué)院下面的各個(gè)系--也是迭代器需要遍歷的對(duì)象
public class Department
{
    private String name;//名字
    private Integer score;//分?jǐn)?shù)線(xiàn)
}

//抽象學(xué)院接口
public interface College
{
  //獲取當(dāng)前系的名字
    void getName();
    //增加系
    void addDepartment(String name,Integer score);
    //返回一個(gè)迭代器，負(fù)責(zé)遍歷
    Iterator createIterator();
}

public class ComputerCollege implements College{
    //數(shù)組默認(rèn)大小為10
    private Department[] departments=new Department[10];
    private  Integer numOfDepartment=0;//當(dāng)前數(shù)組中保存的對(duì)象個(gè)數(shù)
    @Override
    public void getName() {
        System.out.println("計(jì)算機(jī)學(xué)院");
    }
   //獲取到對(duì)應(yīng)的系集合
    public ComputerCollege(Department[] departments)
    {
        int i=0;
        for (Department department : departments) {
            this.departments[i++]=department;
        }
    }
 //增加系
    @Override
    public void addDepartment(String name,Integer score)
    {
     Department department=new Department(name,score);
     departments[numOfDepartment++]=department;
    }
//創(chuàng)建對(duì)應(yīng)的迭代器，并傳入要遍歷的集合給迭代器
    @Override
    public Iterator createIterator() {
        return new ComputerCollegeIterator(departments);
    }
}

//信息學(xué)院
public class InfoCollegeIterator implements Iterator
{
 //以list的方式存放系
    private List<Department> departments;
    //索引
    private  Integer index=0;
    InfoCollegeIterator(List<Department> departments)
    {
        this.departments=departments;
    }
    //判斷l(xiāng)ist集合中是否還有下一個(gè)元素
    @Override
    public boolean hasNext() {
          if(index>departments.size()-1)
          {
              return false;
          }
          return true;
    }
    @Override
    public Object next() {
        return departments.get(index++);
    }
    @Override
    public void remove() {
    }
}

public class OutputImp
{
 //學(xué)院集合
 private List<College> collegeList;
 public OutputImp(List<College> collegeList)
 {
     this.collegeList=collegeList;
 }
 //輸出所有學(xué)院，以及學(xué)院下面的所有系
    public  void printColleges()
    {
        //獲取到遍歷學(xué)院集合需要用到的迭代器
        //list集合實(shí)現(xiàn)了iterator接口
        Iterator<College> collegeIterator = collegeList.iterator();
        while(collegeIterator.hasNext())
        {
            College college = collegeIterator.next();
            System.out.println("當(dāng)前學(xué)院:");
            college.getName();
            System.out.println("當(dāng)前學(xué)院下面的系:");
            //如果要遍歷當(dāng)前學(xué)院下面的所有系，需要獲取對(duì)應(yīng)的迭代器
            printDeparts(college.createIterator());
            System.out.println("=============================");
        }
    }
 //輸出當(dāng)前學(xué)院的所有系
 protected void printDeparts(Iterator iterator)
 {
     while(iterator.hasNext())
     {
         Department department=(Department)iterator.next();
         System.out.println(department.getName());
     }
 }
}

    public static void main(String[] args) {
        List<College> collegeList=new ArrayList<>();
        Department[] departments=new Department[3];
        departments[0]=new Department("c++",520);
        departments[1]=new Department("java",521);
        College college=new ComputerCollege(departments);
         List<Department> departmentList=new ArrayList<>();
        departmentList.add(new Department("密碼學(xué)",520));
        College college1=new InfoCollege(departmentList);
        collegeList.add(college);
        collegeList.add(college1);
        OutputImp outputImp=new OutputImp(collegeList);
        outputImp.printColleges();
    }

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    transient Object[] elementData; // non-private to simplify nested class access
    private int size;
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }
    public ListIterator<E> listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }
    public Iterator<E> iterator() {
        return new Itr();
    }
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;
        public boolean hasNext() {
            return cursor != size;
        }
        public E next() {
            //...
        }
        public E next() {
            //...
        }
        public void remove() {
            //...
        }
        //...
    }  
    private class ListItr extends Itr implements ListIterator<E> {
        public boolean hasPrevious() {
            return cursor != 0;
        }
        public int nextIndex() {
            return cursor;
        }
        public int previousIndex() {
            return cursor - 1;
        }
        public E previous() {
            //...
        }
        public void set(E e) {
            //...
        }
        public void add(E e) {
            //...
        }
    //...
}

public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();
    E next();
    boolean hasPrevious();  // 返回該迭代器關(guān)聯(lián)的集合是否還有上一個(gè)元素
    E previous();           // 返回該迭代器的上一個(gè)元素
    int nextIndex();        // 返回列表中ListIterator所需位置后面元素的索引
    int previousIndex();    // 返回列表中ListIterator所需位置前面元素的索引
    void remove();
    void set(E var1);       // 從列表中將next()或previous()返回的最后一個(gè)元素更改為指定元素e
    void add(E var1);   
}

public interface Iterator<E> {
    boolean hasNext();
    E next();
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    // 備注：JAVA8允許接口方法定義默認(rèn)實(shí)現(xiàn)
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

public interface Cursor<T> extends Closeable, Iterable<T> {
    boolean isOpen();
    boolean isConsumed();
    int getCurrentIndex();
}
public class DefaultCursor<T> implements Cursor<T> {
    private final DefaultResultSetHandler resultSetHandler;
    private final ResultMap resultMap;
    private final ResultSetWrapper rsw;
    private final RowBounds rowBounds;
    private final ObjectWrapperResultHandler<T> objectWrapperResultHandler = new ObjectWrapperResultHandler<T>();
    // 游標(biāo)迭代器
    private final CursorIterator cursorIterator = new CursorIterator(); 
    protected T fetchNextUsingRowBound() {
        T result = fetchNextObjectFromDatabase();
        while (result != null && indexWithRowBound < rowBounds.getOffset()) {
            result = fetchNextObjectFromDatabase();
        }
        return result;
    }
    @Override
    public Iterator<T> iterator() {
        if (iteratorRetrieved) {
            throw new IllegalStateException("Cannot open more than one iterator on a Cursor");
        }
        iteratorRetrieved = true;
        return cursorIterator;
    }
    private class CursorIterator implements Iterator<T> {
        T object;
        int iteratorIndex = -1;
        @Override
        public boolean hasNext() {
            if (object == null) {
                object = fetchNextUsingRowBound();
            }
            return object != null;
        }
        @Override
        public T next() {
            T next = object;
            if (next == null) {
                next = fetchNextUsingRowBound();
            }
            if (next != null) {
                object = null;
                iteratorIndex++;
                return next;
            }
            throw new NoSuchElementException();
        }
        @Override
        public void remove() {
            throw new UnsupportedOperationException("Cannot remove element from Cursor");
        }
    }
    // ...
}