ArrayList类的底层实现Java

ArrayList的底层实现-Java

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

    public static final int DEFAULT_CAPACITY = 10;

    private int theSize;
    private AnyType[] theItem;

    public MyArrayList() {
    
    
        doClear();
    }

    public void clear() {
    
    
        doClear();
    }

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

    public int size() {
    
    
        return theSize;
    }

    // 判断是否为空
    public boolean isEmpty(){
    
    
        return size() == 0;
    }

    public void trimTosize() {
    
    
        ensureCapacity(size());
    }

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

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

    // 是否扩容
    public void ensureCapacity(int newCapacity) {
    
    
        if (newCapacity < size()) return;

        AnyType[] old = theItem;
        theItem = (AnyType[]) new Object[newCapacity];
        for (int i = 0; i < size(); i++) {
    
    
            theItem[i] = old[i];
        }
    }


    public boolean add(AnyType val) {
    
    
        add(size(), val);
        return true;
    }

    public void add(int idx, AnyType val) {
    
    
        if (theItem.length == size()) {
    
    
            ensureCapacity(size()*2+1);
        }
        for (int i = size(); i > idx; i--) {
    
    
            theItem[i] = theItem[i - 1];
        }
        theItem[idx] = val;
        theSize++;
    }

    public AnyType remove(int idx) {
    
    
        AnyType removeItem = theItem[idx];
        for (int i = idx; i < size() - 1; i++) {
    
    
            theItem[i] = theItem[i+1];
        }
        theSize--;
        return removeItem;
    }

    public java.util.Iterator<AnyType> iterator() {
    
    
        return new ArrayListIerator();
    }

    private class ArrayListIerator implements java.util.Iterator<AnyType> {
    
    
        private int current = 0;

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

        public AnyType next() {
    
    
            if (!hasNext()) {
    
    
                throw new java.util.NoSuchElementException();
            }
            return theItem[current++];
        }

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

测试类

public class myArrayListTest {
    
    
    public static void main(String[] args) {
    
    
        MyArrayList<Integer> list = new MyArrayList<Integer>();
        list.add(1);
        list.add(2);
        for (Integer integer : list) {
    
    
            System.out.println(integer);
        }
        System.out.println(list.size());
        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        list.add(8);
        System.out.println(list.size());
        for (Integer integer : list) {
    
    
            System.out.println(integer);
        }

        System.out.println("clear");
        list.clear();
        for (Integer integer : list) {
    
    
            System.out.println(integer);
        }
    }
}