手写源码系列之ArrayList

手写ArrayList的实现，大致逻辑和原生中的大同小异！仅供学习参考

ArrayList的底层是数组实现，默认容量为10，容量不足时进行扩容，每次扩容会增加当前容量大小的一半，比如当前集合里有100条数据，触发扩容会增加至150个容量大小

在平时工作中，如果你明确知道创建的集合要add多少条数据，最好在创建时指定上，否则实际大小大于10的话，会有数组扩容的操作发生，实际值越大，扩容次数越多！消耗性能

import org.junit.Test;

import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.function.Consumer;


public class ArrayListDemo {

    /**
     * 测试方法
     */
    @Test
    public void test1() {
        MyArrayList<Integer> list = new MyArrayList<>();
        //测试数据插入
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        list.forEach(data -> System.out.println(data));
        System.out.println("测试数据删除");
        list.remove(0);
        list.forEach(data -> System.out.println(data));
    }

    /**
     * 测试循环中添加数据
     */
    @Test
    public void test2() {
        MyArrayList<Integer> list = new MyArrayList<>();
        list.add(1);
        list.forEach(data -> {
            list.add(2);
        });
    }

    /**
     * 测试forEach
     */
    @Test
    public void test3() {
        MyArrayList<Father> list = new MyArrayList<>();
        list.add(new Father(1));
        list.forEach(son -> {
            System.out.println(son);
        });

    }

}

class MyArrayList<T> {

    /**
     * 默认容量
     */
    private int defaultCapacity = 10;

    /**
     * 存放数据的数组
     */
    private Object[] datas = {};

    /**
     * 当前集合中的元素个数
     */
    private int size;

    /**
     * 修改次数，主要用与 forEach 遍历时，如果新增或删除了某个元素，循环过程中根据此字段立即感知到并抛出异常，不用非要等到运行到最后才被动的出现异常
     */
    private int modCount;

    /**
     * 获取集合中的数据个数
     *
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 匹配数据
     *
     * @param o
     * @return
     */
    public int indexOf(Object o) {
        if (null == o) {
            for (int i = 0; i < size; i++) {
                if (null == datas[i]) {
                    return i;
                }
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (o.equals(datas[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 匹配数据 从后往前匹配
     *
     * @param o
     * @return
     */
    public int lastIndexOf(Object o) {
        if (null == o) {
            for (int i = size - 1; i >= 0; i--) {
                if (null == datas[i]) {
                    return i;
                }
            }
        } else {
            for (int i = size - 1; i >= 0; i--) {
                if (o.equals(datas[i])) {
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 添加数据
     *
     * @param t
     * @return
     */
    public boolean add(T t) {
        //确保内部容量
        ensureCapacityInternal(size + 1);
        datas[size++] = t;
        modCount++;
        return true;
    }

    /**
     * 添加一组数据
     *
     * @param myArrayList
     * @return
     */
    public boolean addAll(MyArrayList<T> myArrayList) {
        //确保内部容量
        ensureCapacityInternal(size + myArrayList.size);
        for (int i = 0; i < myArrayList.size; i++) {
            datas[size++] = myArrayList.get(i);
        }
        modCount++;
        return true;
    }

    /**
     * 获取数据通过下标
     *
     * @param i
     * @return
     */
    public T get(int i) {
        rangeCheck(i);
        return (T) datas[i];
    }


    /**
     * lambda表达式循环数据
     *
     * @param consumer
     */
    public void forEach(Consumer consumer) {
        final int partModCount = modCount;
        for (int i = 0; partModCount == modCount && i < size; i++) {
            consumer.accept(datas[i]);
        }
        if (partModCount != modCount) {
            throw new ConcurrentModificationException("遍历过程中，集合被修改了");
        }
    }

    /**
     * 删除单个元素根据下标
     *
     * @param index 下标
     * @return
     */
    public T remove(int index) {
        T oldData = get(index);
        for (int i = index; i < size - 1; i++) {
            datas[i] = datas[i + 1];
        }
        datas[--size] = null;
        modCount++;
        return oldData;
    }

    /**
     * 下标检测
     *
     * @param i
     */
    private void rangeCheck(int i) {
        if (i >= size) {
            throw new RuntimeException("数组下标越界");
        }
    }

    /**
     * 确保内部容量
     *
     * @param minCapacity
     */
    private void ensureCapacityInternal(int minCapacity) {
        if (datas.length == 0) {
            //还没有任何数据的情况
            minCapacity = Math.max(minCapacity, defaultCapacity);
            datas = Arrays.copyOf(datas, minCapacity);
        } else {
            if (minCapacity > datas.length) {
                //进行数组扩容
                int oldCapacity = datas.length;
                //容量扩充当前容量的一半
                int newCapacity = oldCapacity + (oldCapacity >> 1);
                if (newCapacity < minCapacity) {
                    newCapacity = minCapacity;
                }
                //最大不能超过int最大范围
                if (newCapacity > Integer.MAX_VALUE) {
                    if (minCapacity > Integer.MAX_VALUE) {
                        System.out.println("容量最大不能超过int的最大长度");
                    } else {
                        newCapacity = Integer.MAX_VALUE;
                    }
                }
                datas = Arrays.copyOf(datas, newCapacity);
            }
        }
    }

    public Object[] toArrays() {
        return Arrays.copyOf(datas, size);
    }

    /**
     * 打印方法
     */
    public void print() {
        if (size == 0) {
            System.out.println("没有数据");
            return;
        }
        for (int i = 0; i < size; i++) {
            System.out.print(datas[i] + " ");
        }
        System.out.println();
    }
}