Java实现具有迭代器的顺序表

关于如何在自己定义的数据结构实现迭代器，请看这篇文章：https://www.cnblogs.com/xujian2014/p/5846128.html

下面附上我的代码：

package DataStructure;

/**
 * Created with IntelliJ IDEA
 * User:12089
 * Date:2019/2/28
 * Time:21:28
 * Description:基于数组实现的顺序表
 **/

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;



interface Sequence<T>{

    /**
     * 向线性表中添加元素
     * @param newdata 要存储的元素
     * @return 插入成功，返回true
     */
    boolean add(T newdata);


    /*
    * 在指定索引出插入一个元素
    * @param index 指定位置处索引 newdata 要插入的元素
    */
    void insert(int index,T newdata);


    /**
     * 线性表中删除元素
     * @param index 要删除的元素下标
     * @return 是否删除成功
     */
    T remove(int index);


    /*
    * 在指定索引处添加新元素
    *  @param index 指定的位置处的索引 newdata 要添加的元素
    */
    T set(int index,T newData);

    /**
     * 在线性表中查找指定索引的元素
     * @param index 要查找的索引
     * @return
     */
    T get(int index);

    /*
    *  对原数组进行扩容操作
    * @param newCapacity 要扩容的大小
    */
    void ensureCapacity(int newCapacity);


    /*
    * 判断该顺序表是否为空
    * @param
    * @return 为空返回true,否则返回false
    */
    boolean isEmpty();


    /*
    * 返回指定元素的所有
    * @param obj 指定元素
    * @return 返回索引值
    */
    int IndexOf(Object obj);

    /**
     * 判断线性表中是否有指定元素
     * @param obj 要查找的元素内容
     * @return
     */
    boolean contains(Object obj);



    /*
    * 获得该顺序表元素的个数
    *  @param
    *  @return 返回元素的个数值
    */
    int getSize();


    /*
    * 将该顺序表转换为一个泛型数组
    * @param
    * @return 返回一个泛型数组
    */
    T[] toArray();


    /*
    * 清空该顺序表
    *  @param
    *  @return
    */
    void clear();
}


public class SequenceList<T> implements Sequence<T>,
        Iterable<T> {
    private int size;
    private static final int DEFAULT_CAPACITY=20;
    private static final Object[] EMPTY_ELEMENTDATA = {};
    public transient T[] elementData;


    public SequenceList() {
        this.elementData=(T[]) new Object[DEFAULT_CAPACITY];
    }

    public SequenceList(int InitCapacity){
        if(InitCapacity>0){
            this.elementData=(T[])new Object[InitCapacity];
            this.size=0;
        }else if(InitCapacity==0){
            this.elementData=(T[])EMPTY_ELEMENTDATA;
        }else {
            throw new IllegalArgumentException();
        }
    }

    @Override
    public void ensureCapacity(int newCapacity) {
        int cur=elementData.length;
        if(cur<newCapacity){
            elementData= Arrays.copyOf(elementData,newCapacity);
        }
    }

    private void CheckRange(int index){
        if(index<0||index>getSize()-1){
            throw new IndexOutOfBoundsException();
        }
    }

    @Override
    public boolean add(T newdata) {
        if(size==elementData.length){
            ensureCapacity(elementData.length*2+1);
        }

        elementData[size++]=newdata;
        return true;
    }

    @Override
    public void insert(int index, T newdata) {
        CheckRange(index);


        if(elementData.length==size){
            ensureCapacity(elementData.length*2+1);
        }

        System.arraycopy(elementData,index,elementData,index+1,size-index);
        elementData[index]=newdata;
        size++;
    }

    @Override
    public T remove(int index) {
        CheckRange(index);

        int movedsize=size-index-1;
        T oldData=elementData[index];

        if(movedsize>0){
            System.arraycopy(elementData,index+1,
                    elementData,index,movedsize);
        }

        //如果是数组最后一个元素
        elementData[--size]=null;
        return oldData;
    }

    @Override
    public T set(int index, T newData) {
        CheckRange(index);

        T oldData=elementData[index];
        elementData[index]=newData;
        return oldData;
    }

    @Override
    public T get(int index) {
        return elementData[index];
    }

    @Override
    public boolean isEmpty() {
        return this.size==0;
    }

    @Override
    public int IndexOf(Object obj) {
        int len=elementData.length;
        if(obj==null){
            for(int i=0;i<len;i++){
                if(elementData[i]==null){
                    return i;
                }
            }
        }else{
            for(int i=0;i<len;i++){
                if(obj.equals(elementData[i])){
                    return i;
                }
            }
        }
        return -1;
    }

    @Override
    public boolean contains(Object obj) {
        return IndexOf(obj)!=-1;
    }

    @Override
    public int getSize() {
        return this.size;
    }

    @Override
    public T[] toArray() {
        return Arrays.copyOf(elementData,size);
    }

    @Override
    public void clear() {
        for(int i=0;i<elementData.length;i++){
            elementData[i]=null;
        }
        size=0;
    }


    @Override
    public Iterator<T> iterator() {
        return new SeqListItr();
    }

    private class SeqListItr implements Iterator<T>{
        private int cur=0;

        @Override
        public boolean hasNext() {
            return cur<size;
        }

        @Override
        public T next() {
            return elementData[cur++];
        }

        @Override
        public void remove() {
            SequenceList.this.remove(--cur);
        }
    }

    public static void main(String[] args) {
        SequenceList sequence=new SequenceList();
        sequence.add(1);
        sequence.add(3);
        sequence.add(5);
        sequence.add(7);
        sequence.add(9);
        sequence.insert(3,0);

        sequence.remove(2);
        System.out.println(sequence.isEmpty());
        System.out.println(sequence.getSize());
        System.out.println(sequence.contains(5));

        Iterator itr=sequence.iterator();
        while(itr.hasNext()){
            System.out.println(itr.next());
        }
    }
}