根据线性表算法实现的ArrayList集合

package study.struct.array;

import java.util.Arrays;

public class MyListTable {
        private Object[] elements = null;// 
        private int size = 0;// 个数
        // 动态初始化
        
        public  MyListTable() {
            this(10);//当不指定容量时，默认为10个
        }
        
        public  MyListTable(int initialCapacity) {
            //代码健壮性
            if(initialCapacity < 0) {
                throw new IllegalArgumentException("容量不能为负数");
            }
            elements = new Object[initialCapacity];// 初始化数组容量
        }

        /*
         * 添加
         */
        public void add(Object ele) {
            /*
             * 满了就要数组扩容
             */
            if(size == elements.length) {
                Object[] temp = Arrays.copyOf(elements, elements.length * 2);//扩容机制乘以2
                elements = temp;
            }
            elements[size] = ele;
            size++;//个数随着添加的个数而增长
        }
        /*
         * 打印
         */
        public String toString() {
            if (elements == null) {
                
                return "null";
            }
            if (size == 0) {
                
                return  "[]";
            }
            StringBuilder str = new StringBuilder(size * 2 + 1);
            str.append("[");
            for (int i = 0; i < size; i++) {
                str.append(elements[i]);
                if(i!=size-1) {//判断是否为最后一位
                    str.append(",");
                }else {
                    str.append("]");
                }
            }
            return str.toString();
        }
        /*
         * 获取指定球员，根据索引来取
         */
        public Object get(int index) {
            //代码健壮性
                    if(index < 0 || index >= size) {
                        throw new IllegalArgumentException("索引越界");
                    }
            return elements[index];
        }
        /*
         * 获取指定球员的索引
         */

        public int getIndex(Object ele) {
            
            for (int i = 0; i < size; i++) {
                if(elements[i].equals(ele)) {//底层是equals此处别用==比较，Object有范围
                    return i;
                }
            }
            return -1;
        }
        /*
         * 替换
         */

        public void set(int index, Object newele) {
            //代码健壮性
            if(index < 0 || index >= size) {
                throw new IllegalArgumentException("索引越界");
            }
            elements[index] = newele;
        }
        /*
         * 更新
         */

        public void update(Object oldele, Object newele) {
            int index = getIndex(oldele);
            if(index >= 0) {
                elements[index] = newele;
            }
        }
        /*
         * 按索引删除
         */

        public void delete(int index) {
            for (int i = index; i < size -1; i++) {
                elements[i] = elements[i+1];//后面的元素前移动一位
            }
            elements[size-1] = null;//最后一位设置为null
            size--;//数组容量减1
        }
        //数组的大小
        public int size() {
            return size;
        }
        //判断元素是否为空
        public boolean isEmpty() {
            return size == 0;
        }
        //清空
        public void clear() {
            for (int i = 0; i < size; i++) {
                elements[i] = null;
            }
            size = 0;
        }
}