自定义MyList类，实现ArrayList的基本功能

试题：自定义一个类，命名为 MyList，类中包含属性：Object[] element。

定义如下几个方法：

1. 增加方法add：可以向数组属性中依次存储 Object，数组内容存满时，需实现动态扩容（详解在下面）。
   参考：Boolean add(Object obj)
2. 删除方法remove：可以根据数据或下标，从数组属性中删除Object数据，删除后，数组后续元素需前移。
   参考：void remove(Object obj) 或 void remove(Integer index)
3. 查询方法get：方法传入下标，返回数组中指定下标的数据。
   参考：Object get(Integer index)
4. 当前存储数据量size：获取当前存储的有效数据长度。
   参考：size=数组.length

动态扩容详解：无需真正增加原数组的容量，只用将原内容复制到新的大数组，然后让原数组名称重新等于大数组即可。由于原数组数据在堆中，失去引用会被GC自动回收。（考点：如何实现数组的动态长度）

package homework.chapter3.section5;

import java.util.Arrays;

public class MyList {

    private Object[] elementData = new Object[0];
    private int size = elementData.length;

    public Boolean add(Object o) {
        Object[] temp = new Object[size + 1];

        for (int i = 0; i < elementData.length; i++) {
            temp[i] = elementData[i];
        }

        temp[size++] = o;
        elementData = temp;

        return true;
    }

    /**
     * 根据下标删除数组中的元素
     * @param index
     */
    public Object remove(int index) {
        rangeCheck(index);
        Object oldValue = elementData[index];
        Object[] temp = new Object[size - 1];

        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved);
        }
        elementData[--size] = null;

        System.arraycopy(elementData, 0, temp, 0, temp.length);
        elementData = temp;

        return oldValue;
    }

    /**
     * 若数组中存在多个相同的值，则只删除遇到的第一个值
     * @param o
     */
    public boolean remove(Object o) {
        if (!isExist(o)) {
            System.out.println("输入的元素不存在！");
            return false;
        }

        if (o == null) {
            for (int index = 0; index < size; index++) {
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
            }
        } else {
            for (int index = 0; index < size; index++) {
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
            }
        }
        return false;
    }

    public Object get(int index) {
        return elementData[index];
    }

    public int size() {
        return size;
    }

    public void show() {
        System.out.println(Arrays.toString(elementData));
    }

    /**
     * 此方法为private类型的方法，负责删除对象数组中某个指定的元素
     * @param index
     */
    private void fastRemove(int index) {
        int numMoved = size - index - 1;
        Object[] temp = new Object[size - 1];
        if (numMoved > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
        }
        elementData[--size] = null;

        System.arraycopy(elementData, 0, temp, 0, temp.length);
        elementData = temp;
    }

    /**
     * 此方法为private类型的方法，负责检查下标是否越界
     * @param index
     */
    private void rangeCheck(int index) {
        if (index >= size) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    /**
     * 此方法为private类型的方法，规定了下标越界的异常提示信息
     * @param index
     * @return
     */
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

    /**
     * 此方法为private类型的方法，判断数组中是否存在指定的元素
     * @param o
     * @return
     */
    private boolean isExist(Object o) {
        boolean flag = false;
        for (int i = 0; i < size; i++) {
            if (elementData[i].equals(o)) {
                flag = true;
                break;
            }
        }
        return flag;
    }
}

package homework.chapter3.section5;

import java.util.Scanner;

public class MyListTest {

    public static void main(String[] args) {
        // 创建空数组
        MyList myList = new MyList();

        // 往数组中添加元素
        myList.add("1");
        myList.add("2");
        myList.add("3");
        myList.add("4");
        myList.add("5");
        myList.add("6");

        System.out.println("数组长度为：" + myList.size());
        myList.show();

        System.out.println("请输入要删除的元素：");
        Scanner scanner = new Scanner(System.in);
        Object removeItem = scanner.nextLine();
        myList.remove(removeItem);

        System.out.println("数组长度为：" + myList.size());
        myList.show();

        // 输出下标为2的元素
        System.out.println("下标为2的元素为：" + myList.get(2));

        // 通过remove(int index)方法来删除下标为2的元素
        System.out.println("请输入要删除的元素下标：");
        int removeIndex = scanner.nextInt();
        System.out.println("被删除的元素为：" + myList.remove(removeIndex));
        myList.show();
    }
}

运行结果：

总结：基本实现了题目要求，但为了简化程序，数组初始大小为0，每一次添加元素都会引发动态扩容，后期待改进。