数据结构--表(List)

ArrayList类的实现

public class MyArrayList<AnyType> implements Iterable<AnyType> {

    private static final int DEFAULT_CAPACITY = 10;

    private int theSize;
    private AnyType[] theItems;

    public MyArrayList() {
        doClear();
    }

    public void clear() {
        doClear();
    }

    private void doClear() {
        theSize = 0;
        ensureCapacity(DEFAULT_CAPACITY);
    }

    public int size() {
        return theSize;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    /**
     * ArrayList所说没有用的值并不是null，而是ArrayList每次增长会预申请多一点空间，1.5倍+1，而不是两倍
     * 这样就会出现当size() = 1000的时候，ArrayList已经申请了1200空间的情况 trimToSize
     * 的作用只是去掉预留元素位置，就是删除多余的200，改为只申请1000,内存紧张的时候会用到.
     */
    public void trimToSize() {
        ensureCapacity(size());
    }

    public AnyType get(int idx) {
        if (idx < 0 || idx >= size()) {
            throw new ArrayIndexOutOfBoundsException();
        }
        return theItems[idx];
    }

    public AnyType set(int idx, AnyType newVal) {
        if (idx < 0 || idx >= size())
            throw new ArrayIndexOutOfBoundsException();
        AnyType old = theItems[idx];
        theItems[idx] = newVal;
        return old;
    }

    public void ensureCapacity(int newCapacity) {
        if (newCapacity < theSize) {
            return;
        }

        AnyType[] old = theItems;
        theItems = (AnyType[]) new Object[newCapacity];// 创建一个泛型类型界限的数据，然后使用一个数组进行类型转换
        for (int i = 0; i < theSize; i++) {
            theItems[i] = old[i];
        }
    }

    /**
     * 在数组的最后添加
     * 
     * @param x
     * @return
     */
    public boolean add(AnyType x) {
        add(size(), x);
        return true;
    }

    /**
     * 添加操作，需要将索引后的元素向高位移动一个位置
     * @param idx
     * @return
     */
    public void add(int idx,AnyType x){
        if(theItems.length ==size()){
            ensureCapacity(size()*2+1);
        }
        for (int i = theSize; i >idx; i--) {
            theItems[i] = theItems[i-1];
        }
        theItems[idx] = x;

        theSize++;
    }

    /**
     * 删除操作，需要将索引后的元素向低位移动一个位置
     * @param idx
     * @return
     */
    public AnyType remove(int idx){
        AnyType remoedItem = theItems[idx];
        for (int i = idx; i <size()-1; i--) {
            theItems[i] = theItems[i+1];
        }

        theSize--;
        return remoedItem;
    }

    public Iterator<AnyType> iterator() {
        return new ArrayListIterator();
    }

    private class ArrayListIterator implements Iterator<AnyType>{

        private int current = 0;

        public boolean hasNext() {
            return current<size();
        }

        public AnyType next() {
            if(!hasNext()){
                throw new NoSuchElementException();
            }
            return theItems[current++];
        }

        public void remove() {
            MyArrayList.this.remove(--current);
        }
    }
}