java自写一个ArrayList，并implements Iterable实现foreach遍历

public class MyArrayList implements Iterable<Object>{
    //用于储存数据
    private transient Object[] data = null;
    //集合的元素个数
    private int size=0;
    //定义一个常量，默认为10
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 无参的构造函数
     * 初始数组大小为10
     *
     * @param initialCapacity
     */
    public MyArrayList(int initialCapacity) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("非法的初始容量值：" + initialCapacity);
        } else {
            this.data = new Object[initialCapacity];
        }
    }

    /**
     * 无参的构造函数
     * 指定初始数组大小
     */
    public MyArrayList(){
        this(DEFAULT_CAPACITY);
    }

    /**
     * 1,复制原数组，并扩容一倍
     * 2，复制原数组，并扩容一倍，并在指定位置插入对象
     *
     * @param index
     * @param object
     */
    public void checkIncrease(int index, Object object) {
        System.out.println("size >= data.length"+(size >= data.length)+" size="+size+" data.length"+data.length);
        if (size >= data.length) {
            System.out.println("data.length"+data.length+"size="+size);
            Object[] newData = new Object[size * 2];
            if (index == -1 && object == null) {
                System.arraycopy(data, 0, newData, 0, size);
            } else {
                System.arraycopy(data, index, newData, index + 1, size - index);
                newData[index]=object;
            }
            //把新数组赋值给data数组
            data = newData;
            newData = null;
            System.out.println("data.length"+data.length+"size="+size);
        }
    }

    /**
     * 返回数组大小
     *
     * @return
     */
    public int getSize() {
        return this.size;
    }

    /**
     * 获取索引
     *
     * @param o
     * @return
     */
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < data.length; i++) if (data[i] == null) return i;
        } else {
            for (int i = 0; i < data.length; i++) if (o.equals(data[i])) return i;
        }
        return -1;
    }

    /**
     * 在尾部添加元素
     *
     * @param obj
     * @return
     */
    public boolean add(Object obj) {
        //检查是否需要扩容
        checkIncrease(-1, null);
        data[size++] = obj;
       // System.out.println(size);
        return true;
    }

    /**
     * 判断给定索引是否越界
     *
     * @param index
     * @return
     */
    public boolean checkIndexOut(int index) {
        if (index > size || index < 0) {
            throw new IndexOutOfBoundsException("指定的索引越界，集合大小为:" + size + ",您指定的索引大小为:" + index);
        }
        return true;
    }

    public boolean add(int index, Object object) {
        //如果给定索引的长度刚好等于原数组的长度，那么直接在尾部添加上去
        if (index == size) {
            add(object);
        }//checkIndexOut()如果不抛异常，默认index<=size,且index>0
        else if (checkIndexOut(index)) {
            if (size < data.length) {
                System.arraycopy(data, index, data, index + 1, size - index);
                data[index] = object;
            } else {
                checkIncrease(index, object);
            }
            size++;
        }
        return true;
    }

    /**
     * 根据索引获得元素
     *
     * @param index
     * @return
     */
    public Object get(int index) {
        checkIndexOut(index);
        return data[index];
    }

    /**
     * 删除所有元素
     */
    public void removeAll() {
        for (int i = 0; i < data.length; i++) {
            data[i] = null;
        }
    }

    /**
     * 根据索引删除元素
     *
     * @return
     */
    public Object remove(int index) {
        if (index == size + 1) {
            throw new IndexOutOfBoundsException("指定的索引越界，集合大小为：" + size + ",您指定的索引大小为：" + index);
        } else if (checkIndexOut(index)) {
            Object object = data[index];
            if (index == size) {
                data[index] = null;
            } else {
                System.out.println("test");
                System.arraycopy(data,index+1 ,data ,index ,size-index );
            }
            size--;
            return object;
        }
     return null;
    }


    /**
     * 根据对象删除指定元素，删除成功返回true
     * @param object
     * @return
     */
    public boolean remove(Object object){
        for (int i = 0; i < size; i++) {
            if(object.equals(data[i])){
                remove(i);
                return true;
            }
        }
        return false;
    }


    /**
     * 在指定位置修改元素，通过索引，修改完成后返回原数据
     * @param index
     * @param object
     * @return
     */
    public Object change(int index,Object object){
        checkIndexOut(index);
        Object oldObj=data[index];
        data[index]=object;
        return oldObj;
    }

    /**
     * 查看集合里是否包含某个元素
     * @param object
     * @return
     */
    public boolean contain(Object object){
        for (int i = 0; i < data.length; i++) {
           if(object.equals(data[i])){
               return true;
           }
        }
        return  false;
    }

    class  MyArrayListIterator implements Iterator<Object>{
        Object cuerrentData;
        int i=0;
        public MyArrayListIterator(Object[] data ){
            if(data!=null){
                cuerrentData=data[0];
            }
        }
        @Override
        public boolean hasNext() {
            return cuerrentData!=null;
        }

        @Override
        public Object next() {
            if(cuerrentData==null){
                throw new NoSuchElementException();
            }
            Object value=cuerrentData;
            cuerrentData=data[++i];
            System.out.println(value+"value");
            return value;
        }
    }


    @Override
    public Iterator<Object> iterator() {
        return new MyArrayListIterator(data);
    }

public static void main(String[] args){

//    List my = new ArrayList();
//    //System.out.println(my.data.length);
//    my.add(0,3);
//    //System.out.println(my.getSize());
//    my.add(0,4);
//    //System.out.println(my.getSize());
//    my.add(0,5);
//    //my.removeAll();
//    //my.remove(2);
//    //System.out.println(my.get(2));
//    System.out.println(my.get(0));
//    System.out.println(my.indexOf(null));
//    System.out.println(my.contains(2));
//
//    Iterator iterable=my.iterator();
//    while (iterable.hasNext()){
//        Object object=iterable.next();
//        System.out.println(object);
//    }


    MyArrayList my = new MyArrayList();
    //System.out.println(my.data.length);
    my.add(3);
    //System.out.println(my.getSize());
    my.add(4);
    //System.out.println(my.getSize());
    my.add(5);
    my.add(15);
    my.add(25);
    my.add(35);
    my.add(45);
    my.add(55);
    my.add(65);
    my.add(75);
    my.add(85);
    for (Object i:my) {
        System.out.println("foreach测试"+i);
    }
    //my.removeAll();
//    my.remove(13);
    //System.out.println(my.get(2));
    System.out.println("size"+my.getSize());
    System.out.println(my.indexOf(null));
    System.out.println(my.contain(2));
    for(int i = 0 ; i < my.data.length ; i++){
        System.out.println(my);
    }


//    ArrayList my = new ArrayList();
//    //System.out.println(my.data.length);
//    my.add(0,3);
//    //System.out.println(my.getSize());
//    my.add(1,4);
//    //System.out.println(my.getSize());
//    my.add(2,5);
//    my.add(3,15);
//    my.add(4,25);
//    my.add(5,35);
//    my.add(6,45);
//    my.add(7,55);
//    my.add(8,65);
//    my.add(9,75);
//    my.add(10,85);
//
//    //my.removeAll();
//    //my.remove(2);
//    //System.out.println(my.get(2));
//    System.out.println("size"+my.size());
//    System.out.println(my.indexOf(null));
//    System.out.println(my.contains(2));
//    Iterator iterable=my.iterator();
//    while (iterable.hasNext()){
//        Object object=iterable.next();
//        System.out.println(object);
//    }
}


}