在java集合中，Collection基介面實現List（陣列），Set（集合），Queue（佇列）三個介面，而List又實現了AbstractList介面，ArrayList類就繼承了AbstractList介面。

        ArrayList底層就是一個數組，預設陣列大小是10，查詢效率高，1.5倍擴容，基於陣列索引來定位資料，我們在使用的時候可以用兩種方法來建立ArrayList陣列（如下）：

ArrayList<Integer>integers = new ArrayList();  //無參的陣列初始化，陣列預設大小是10

ArrayList<Integer>list = new ArrayList();  //有參構造，指定初始化陣列大小

在其中，原始碼中為我們提供了add，remove，get等一些方法，我們可以直接使用。

public class ArrayListDemo {
    public static void main(String[] args) {
        /**
         * 無參的陣列初始化，陣列預設大小是10
         */
        ArrayList<Integer>integers = new ArrayList();
        /**
         * 有參構造，指定初始化陣列大小
         */
        ArrayList<Integer>list = new ArrayList();
        //add 新增資料
        list.add(1);
        list.add(3);

        //查詢集合是否包含當前查詢元素
        list.addAll(integers);
        //System.out.println(list.contains(3));
        list.contains(3);

        //刪除指定元素
        list.remove(1);

        //獲取集合容量大小
        int size = list.size();
        //System.out.println(size);

        for (int i = 0;i <size;++i){
            //get獲得指定位置索引資料
            //System.out.println(list.get(i));
        }
    }
}
 

下面我們將自己實現一個簡單的ArrayList，完成他的add，remove以及get三個簡單的方法：

class MyArrayList {
    private int[] array;
    private int usedsize = 0;
    public javaTest(){
        this(10);
    }
    public javaTest(int usedsize){
        this.usedsize = usedsize;
        this.array = new int[usedsize];
    }

    /**
     * add方法
     * @param
     * @return
     */
    public  boolean add(int val){
        if (isFull()){
            this.array = Arrays.copyOf(this.array,this.array.length*2);
        }
        this.array[this.usedsize++] = val;
        return true;
    }
    /**
     * remove方法
     */
    public  boolean remove(int val){
        int i = 0;
        for (;i < usedsize;i++){
            if (this.array[i] == val){
                break;
            }
        }
        for (i = i-1;i+1 < this.usedsize;++i){
            this.array[i] = this.array[i+1];
        }
        this.usedsize--;
        return true;
    }
    /**
     * get方法
     */
    public  int get(int key){
        if (key > this.usedsize){
            throw new ArrayIndexOutOfBoundsException("Array is over");
        }
        return this.array[key];
    }
    public boolean isFull(){
        return this.usedsize == this.array.length;
    }
    public int getSize(){
        return this.usedsize;
    }

}
 

        Iterator（迭代器）是一種設計模式，迭代器提供一種方法，來訪問集合（容器），對集合進行遍歷特點：達到對集合的遍歷訪問與集合底層資料結構進行解耦。下面我們將自己實現一個簡單的Iterator：

public class MyArrayList<T> implements Iterable<T>{
    private T[] data;
    private int size;

    public  MyArrayList() {
        this(10);
    }

    public MyArrayList(int capcity) {
        data = (T[])new Object[capcity];
        size = 0;
    }

    private boolean isFull () {
        return size == data.length;
    }

    public void add(T value) {
        if (isFull()) {
            data = Arrays.copyOf(data, data.length<<1+data.length>>1);
        }
        data[size++] = value;
    }

    public T remove(int index){
        if (index < 0 || index > size) {
            return null;
        }

        T oldValue = data[index];
        //陣列移動操作
        for (int i= index; i < size; i++) {
            data[i]= data[i+1];
        }
        data[size-1] = null;
        size--;
        return oldValue;
    }



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

    class MyIterator implements Iterator<T> {
        private int index = 0;

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

        @Override
        public T next() {
            T value = data[index];
            index++;
            return value;
        }

        @Override
        public void remove() {
            MyArrayList.this.remove(index);
            index--;
        }
    }


    public static void main(String[] args) {
        MyArrayList <Integer> list = new MyArrayList <Integer>();
        list.add(1);
        list.add(2);
        list.add(3);

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println(next);
        }
    }


}