设计模式之Iterator模式优化

当当当，书接上回，上次发的Iterator模式太过糟糕，耦合性巨高，感觉根本无法复用，这次通过接口，泛型将该模式尽可能进行改进，使其达到一些复用的效果。
直接看代码，这是新的集合要求实现的接口

/**
 * @author lenovo
 * @title: CommAggregate
 * @projectName LearnDesignMode
 * @description: 通用迭代器集合要实现的接口  
 * 之前要求集合实现的接口里仅有要求返回迭代器这一项，为实现代码的复用，我们对集合提出更多的要求
 * @date 2022/5/323:04
 */
public interface CommAggregate {  

    public abstract CommIterator iterator();

    //返回当前元素个数
    public abstract int getLength();

    //追加元素
    public abstract boolean appendItem(Object o);

    //按索引获取元素
    public abstract Object getItemAt(int index);

}

迭代器的接口依旧没变：

public interface CommIterator {
    //判断是否还有下一个元素
    public abstract boolean hasNext();

    //获取下一个元素
    public abstract Object next();
}

接下来是重要的一部分，迭代器类的实现：

public class CommIteratorClass<T extends CommAggregate> implements CommIterator {

    private T items;
    private int index;

    public CommIteratorClass(T items) {
        this.items = items;
        this.index = 0;
    }

    @Override
    public boolean hasNext() {
        if(this.index < items.getLength()) {
            return true;
        }
        return false;
    }

    @Override
    public Object next() {
        if(hasNext()) {
            return this.items.getItemAt(this.index++);
        }
        return null;
    }
}

使用了泛型，我们要求参数类型必须是实现了集合接口CommAggregate的类，方便我们调用该类的一些成员方法。
接下来去定义一个元素类和集合类并进行测试：

public class Item {
    private int num;

    public Item(int num) {
        this.num = num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public int getNum() {
        return this.num;
    }
}

public class ItemAggregate implements CommAggregate{

    private Item[] items;

    private int last;

    public ItemAggregate(int maxSize) {
        this.items = new Item[maxSize];
        this.last = 0;
    }

    @Override
    public CommIterator iterator() {
        return new CommIteratorClass<ItemAggregate>(this);
    }

    @Override
    public int getLength() {
        return this.last;
    }

    @Override
    public boolean appendItem(Object o) {
        if(this.last < this.items.length) {
            this.items[this.last++] = (Item)o;
            return true;
        }
        return false;
    }

    @Override
    public Object getItemAt(int index) {
        if(index >= 0 && index < this.last) {
            return this.items[index];
        }
        return null;
    }
}

进行测试：

public class Main {
    public static void main(String[] args) {
        CommAggregate commAggregate = new ItemAggregate(4);

        commAggregate.appendItem(new Item(4));
        commAggregate.appendItem(new Item(1));
        commAggregate.appendItem(new Item(8));
        commAggregate.appendItem(new Item(3));

        CommIterator commIterator = commAggregate.iterator();
        while(commIterator.hasNext()) {
            Item item = (Item)commIterator.next();
            System.out.println(item.getNum());
        }
    }
}

输出结果：

4
1
8
3

成功！