/**
 * 抽象聚合角色
 * @author tcy
 * @Date 13-09-2022
 */
public interface InterfaceAggregate {
    /**
     * 增加對(duì)象
     * @param obj 對(duì)象
     */
    void add(Object obj);

    /**
     * 移除對(duì)象
     * @param obj 對(duì)象
     */
    void remove(Object obj);

    /**
     * 調(diào)用迭代器
     * @return 迭代器
     */
    Iterator getIterator();
}

/**
 * 具體聚合角色
 * @author tcy
 * @Date 13-09-2022
 */
public class ConcreteAggregate implements InterfaceAggregate{
    private List<Object> list = new ArrayList<>();
    @Override
    public void add(Object obj) {
        list.add(obj);
    }

    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }

    @Override
    public Iterator getIterator() {
        return new Concretelterator(list);
    }
}

/**
 * 抽象迭代器
 * @author tcy
 * @Date 13-09-2022
 */
public interface Iterator<E> {

    /**
     * 刪除對(duì)象
     * @return 對(duì)象
     */
    Object remove();

    /**
     * 調(diào)用下一個(gè)對(duì)象
     * @return 對(duì)象
     */
    E next();

    /**
     * 迭代器中是否還有下一個(gè)對(duì)象
     * @return
     */
    boolean hasNext();

    /**
     * 遍歷迭代器中剩余的對(duì)象
     * @param action
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }

}

/**
 * 具體迭代器角色
 * @author tcy
 * @Date 13-09-2022
 */
public class Concretelterator implements Iterator{
    private List<Object> list = null;
    private int index = -1;

    public Concretelterator(List<Object> list) {
        this.list = list;
    }

    @Override
    public Object remove() {
        index = list.size();
        Object obj = list.get(index);
        list.remove(obj);
        return obj;
    }

    @Override
    public Object next() {
        Object obj = null;
        if (this.hasNext()) {
            obj = list.get(++index);
        }
        return obj;
    }

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

/**
 * @author tcy
 * @Date 13-09-2022
 */
public class Client {

    public static void main(String[] args) {
        ConcreteAggregate concreteAggregate=new ConcreteAggregate();
        concreteAggregate.add("老王");
        concreteAggregate.add("小王");
        concreteAggregate.add("小張");

        System.out.println("Aggregate聚合對(duì)象有：");

        Iterator iterator=concreteAggregate.getIterator();

        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next.toString());
        }
        //遍歷剩下的角色
        iterator.forEachRemaining(ele -> System.out.println(ele));

    }

}

public class Client {

    public static void main(String[] args) {
      
        // jdk ArrayList迭代器
        //創(chuàng)建一個(gè)元素類型為Integer的集合
        Collection<String> collection =  new ArrayList<>();

            //向集合中添加元素
            collection.add("老王");
            collection.add("小王");
            collection.add("小張");

        //獲取該集合的迭代器
        java.util.Iterator<String> iteratorJdk= collection.iterator();
        System.out.println("Arraylist聚合對(duì)象有：");
        //調(diào)用迭代器的經(jīng)過(guò)集合實(shí)現(xiàn)的抽象方法遍歷集合元素
        while(iteratorJdk.hasNext())
        {
            System.out.println(iteratorJdk.next());
        }
        //調(diào)用forEachRemaining()方法遍歷集合元素
        iteratorJdk.forEachRemaining(ele -> System.out.println(ele));

    }

}