模拟(手写)ArrayList

1、自定义异常类

IllegalArgumentMyException类

package com.example.demo.collection;

/**
 * @Description 自定义非法参数异常
 * @Auther gf.x
 * @Date 2020/5/24 15:38
 */
public class IllegalArgumentMyException extends RuntimeException{

    public IllegalArgumentMyException() {
    }

    public IllegalArgumentMyException(String message) {
        super(message);
    }
}

IndexOutOfBoundsMyException类

package com.example.demo.collection;

/**
 * @Description 自定义数组索引越界异常
 * @Auther gf.x
 * @Date 2020/5/24 16:58
 */
public class IndexOutOfBoundsMyException extends RuntimeException{
    public IndexOutOfBoundsMyException() {
    }

    public IndexOutOfBoundsMyException(String message) {
        super(message);
    }
}

2、模拟ArrayList类实现

SimulateArrayList类

package com.example.demo.collection;

/**
 * @Description 模拟(手写)ArrayList
 * 步骤：
 * 1、定义常量
 * 2、定义成员变量
 * 3、定义构造方法
 * 4、定义操作(容器)成员变量的方法
 *
 * @Auther gf.x
 * @Date 2020/5/24 15:14
 */
public class SimulateArrayList<E> /*implements List, Serializable*/ {
    //不指定大小的默认空实例数组
    private static final Object[] DEFAULT_EMPTY_ELEMENTDATA = {};

    //容器数组默认初始化大小
    private static final int DEFAULT_CAPACITY = 10;

    //存放元素的数组容器
    private Object[] elementData;

    //数组容器中元素数量
    private int size;

    public SimulateArrayList() {
        this(DEFAULT_CAPACITY);
    }

    public SimulateArrayList(int initialCapacity) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentMyException("非法参数");
        }
        elementData = new Object[initialCapacity];
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean add(E e) {
        //扩容和复制
        ensureCapacityInternal();

        elementData[size++] = e; //size++先赋值后加加
        return true;
    }

    public void add(int index, E element) {
        rangeCheck(index);
        //扩容和复制
        ensureCapacityInternal();

        //指定索引位置添加元素，右边元素右移
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
    }

    public E get(int index) {
        rangeCheck(index);
        return elementData(index); //index < 0 时此处会抛越界异常
    }

    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

    public E remove(int index) {
        rangeCheck(index);
        E oldValue = elementData(index);

        //删除索引位置元素，右边元素左移
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
        }
        elementData[--size] = null;
        return oldValue;
    }

    public boolean remove(Object obj) {
        if (obj == null) {
            for (int i = 0; i < size; i++) {
                if (elementData[i] == null) {
                    fastRemove(i);
                    return true;
                }
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (obj.equals(elementData[i])) {
                    fastRemove(i);
                    return true;
                }
            }
        }
        return false;
    }

    //扩容和复制
    private void ensureCapacityInternal() {
        if (size >= elementData.length) {
            Object[] newArray = new Object[elementData.length << 1];
            System.arraycopy(elementData, 0, newArray, 0, elementData.length);
            elementData = newArray;
        }
    }

    private void fastRemove(int index) {
        //删除索引位置元素，右边元素左移
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index, numMoved);
        elementData[--size] = null;
    }

    @SuppressWarnings("unchecked")
    private E elementData(int index) {
        return (E) elementData[index];
    }

    private void rangeCheck(int index) {
        if (index >= size) { //数组索引本身就是大于0的，所以这里可以不加 index < 0
            throw new IndexOutOfBoundsMyException("索引越界");
        }
    }
}

3、测试类

package com.example.demo.collection;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @Description ArrayList容器的使用
 * @Auther gf.x
 * @Date 2020/5/22 18:27
 */
public class TestList {

    @Test
    public void test() {
        List list = new ArrayList();

        list.add(111);
        list.add("abdc");
        list.add(new Date());
        System.out.println(list);
        list.remove(new Date()); //移除成功 hashCode equals
        System.out.println(list);
    }

    @Test
    public void test1() {
        SimulateArrayList list = new SimulateArrayList();
        list.add("aaaa");
        list.add("aaaa");
        list.add("aaaa");
        list.remove(1);
        //System.out.println(list.get(-5)); //索引小于0，抛索引越界异常
        System.out.println(list.get(2));

    }
}