ArrayList的int实现

ArrayList是使用频率很高的类，我仿照Java自带的造了一个轮子。

public class ArrayList {
    private int size=0;
    private int[]element;
    public ArrayList()
    {
       this(100);
    }
    public ArrayList(int num)
    {
        element=new int[num];
    }
    private void checkIndex(int index)
    {
        if (index>=size||index<0)
        {
            throw new IndexOutOfBoundsException("Index  "+index);
        }
    }
    public  int get(int index)
    {
        checkIndex(index);
        return  element[index];
    }
    public void set(int index,int value)
    {
        checkIndex(index);
        element[index]=value;
    }
    public void clear()
    {
        size=0;
    }
    public  void ensureCapacity(int capacity)
    {
        if (capacity >element.length)
        {
            int newCapacity=element.length*2+1;
            if (capacity>newCapacity)
            {
                newCapacity=capacity;
            }
            int []newList=new int[newCapacity];
            for (int i=0;i<size;i++)
            {
                newList[i]=element[i];
            }
            element=newList;
        }
    }
    public int size()
    {
        return  size;
    }
    public ArrayIntListIterator iterator()
    {
        return new ArrayIntListIterator(this);
    }
    public boolean isEmpty()
    {
        return size==0;
    }
    public  boolean cantains(int values)
    {
        return indexOf(values)>=0;
    }
    public void add(int value)
    {
        ensureCapacity(size+1);
        element[size]=value;
        size++;
    }
    public void add(int index,int value)
    {
        ensureCapacity(size+1);
        for (int i=size;i>index;i--)
        {
           element[i]=element[i-1];
        }
        element[index]=value;
    }
    @Override
    public String toString()
    {
        String result;
        if (size==0)
        {
            return "[]";
        }else {
            result = "[" + element[0];
            for (int i = 1; i < size; i++)
            {
                result+=","+element[i];
            }
            result+="]";
        }
        return result;
    }
    public int indexOf(int value)
    {
        for (int i=0;i<size;i++)
        {
            if (element[i]==value)
            {
                return  i;
            }
        }
        return  -1;
    }
    public void remove(int index)
    {
        checkIndex(index);
        for (int i=index;i<size-1;i++)
        {
            element[i]=element[i+1];
        }
        size--;
    }
}

迭代器实现

    关于迭代器，刚开始我纳闷为什么只是传给了迭代器一个参数，迭代器就可以对原数组进行操作。后来我意识到迭代器中声明了一个数组，随后他让这个数组指向了参数，因为数组不是基本数据类型，这样迭代器对数组的操作都是对原数组的操作。

  对于数组和其他对象来说，变量中并不存储实际数据，相反，实际数据存储在一个对象中，而变量中存储的是该对象实际存储位置的引用。结果，计算机的内存中有两个不同的元素：变量和对象。

public class ArrayIntListIterator {
    private ArrayList list;
    private int position;
    private boolean removeOk;
    public  ArrayIntListIterator(ArrayList list)
    {
        this.list=list;
        position=0;
        removeOk=false;
    }
    public boolean hasNext()
    {
        return position<list.size();
    }
    public int next()
    {
        removeOk=true;
        int result=list.get(position);
        position++;
        return result;
    }
        public void remove()
        {
            if (!removeOk)
            {
                throw new IllegalStateException();
            }
            list.remove(position-1);
            position--;
            removeOk=false;
        }
}

主函数

public class Main {

    public static void main(String[] args) {
    ArrayList a=new ArrayList();
    a.add(10);
    a.add(20);
    ArrayIntListIterator it=a.iterator();
    int sum=0;
    while (it.hasNext())
    {
        sum+=it.next();

    }
    System.out.println(a.size());
    it.remove();
    System.out.println(a.size());
    }
}