ArrayList底层实现以及Iterator

        在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);
        }
    }


}