ArrayList底层实现

在java集合框架库中，最顶层的是Collection接口，List(数组)、Set(集合)、Queue(队列)三个接口实现了Collection基接口，而AbtractCollection又实现了List接口，ArrayList类则继承于AbtractCollection接口。

特性：

ArrayList类底层数据结构为数组，初始化大小：DEFAULT-CAPACITY=10，扩容方式：oldCapacity+oldCapacity>>1,即1.5倍扩容。数据有序性；可添加多个null值。
方法：增加元素add(T value)尾部添加；删除元素①index 下标删除②（Object o）值删除。

下面我们实现一个简单的ArrayList，完成基本的expend、add、delete、get等方法。

public class MyArrayList<T extends Comparable<T>> {
    private T[] arr;
    private int size=0;
    
    public MyArrayList(){
        arr = (T[]) new Object[]; 
        size = 0;
    }

    public boolean isFull(){  // 判满
        return size==arr.length;
    }

    public void expends(){  // 扩容，源码1.5倍扩容
        int oldCapacity = arr.length;
        int newCapacity = oldCapacity + (oldCapacity>>1);
        arr = Arrays.copyOf(arr,newCapacity);
    }

    public void add(T value){  // 尾部添加
        if(isFull()){
            expends();
        }
        arr[size++]=value;
    }

    public void delete(int index){  // 根据index下标删除
        System.arraycopy(arr,index+1,arr,index,size-index+-1);
        arr[--size] = null;
    }
    public  boolean remove(T value){  // 根据值删除
        int i = 0;
        for (;i < size;i++){
            if (this.arr[i] == value){
                break;
            }
        }
        for (i = i-1;i+1 < size;++i){
            arr[i] = arr[i+1];
        }
        size--;
        return true;
    }

    public T get(int index){
        if(index>this.size){
            throw new ArrayIndexOutOfBoundsException();
        }
        return arr[index];
    }

    public int get(){
        return size;
    }

    public void show(){
        for(int i=0;i<size;i++){
            System.out.print(arr[i]+"   ");
        }
        System.out.println();
    }
    }

数组和ArrayList的区别：
1.数组：可以存放引用数据类型，基本数据类型
ArrayList：只能存放引用数据类型
2.数组：不可以扩容
ArrayList：可以扩容

在ArrayList实现Iterator迭代器。迭代器，提供一种访问一个集合对象各个元素的途径，本质上就是一种遍历的算法，在迭代器Iteartor接口中，有以下3个方法：hasNext()、next()、remove()。

public Iterator<T> iterator(){
        return new MyItr();
    }
    private class MyItr implements Iterator<T>{

        private int index;
        private int expectedModCount = modCount;

        @Override
        public boolean hasNext() {   //是否存在下一个元素
            return index < size;
        }

        @Override
        public T next() { //获取当前对象的值，并跳到下一个对象
            T value = arr[index];
            index++;
            return value;
        }

        @Override
        public void remove() {
            delete(index);
        }
    

迭代器主要的用法是：首先用hasNext（）作为循环条件，再用next（）方法得到每一个元素，最后在进行相关的操作。

ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);

        //第一种打印(遍历)方式-->print ，LinkedList也适用
        System.out.println(arrayList);

        //第二种打印（遍历）方式 --> 迭代器，LinkedList也适用
        Iterator<Integer> iterator = arrayList.iterator();
        while (iterator.hasNext() == true){ // 是否有下一个值
            Integer a = iterator.next(); // ①获取当前值 ②跳到下一个
//            iterator.remove();  // 删除前一个，即上一步获取的元素
            System.out.println(a);
        }