手动实现动态数组二(java)

package com.batac;

/**
 * Author: Batac
 * 动态数组:
 * 数组: 是一种连续存储结构的线性表;
 * 优点: 查询速度快, 根据地址直接查找到元素(寻址法);
 * 缺点: 插入与删减元素速度差, 最差需要移动其他所有元素
 */
public class ArrayList<E> {

    //数组
    private E[] elements;

    //元素个数
    private int size;

    //容量
    private static int CAPATICY = 10;
    //没有找到指定元素
    private static final int ELEMENT_NOT_FOND = -1;


    /**
     * 有参构造方法
     * @param capaticy
     */
    public ArrayList(int capaticy){
        if (capaticy < CAPATICY)capaticy = CAPATICY;
        //注意点:泛型必须是对象类型, 基础类型不行
        
        elements = (E[]) new Object[capaticy];
    }

    /**
     * 无参构造方法
     */
    public ArrayList(){
        this(CAPATICY);
    }

    /**
     * 设置元素个数
     * @return
     */
    public int sise(){
        return this.size;
    }


    /**
     * 判断元素是否为空
     * @return
     */
    public boolean isEmpty(){
        if (this.sise() > 0)return false;
        return true;
    }

    /**
     * 判断元素是否存在
     * @param element
     * @return
     */
    public boolean contains(E element){
        return indexOf(element) > 0;
    }


    /**
     * 添加元素
     * @param element
     */
    public void add(E element){
        add(size,element);
    }

    /**
     * 获取指定索引出元素
     * @param index
     * @return
     */
    public E get(int index){
        indexOutOfBoundsExceptioni(index);
        return elements[index];
    }

    /**
     * 设置元素到指定位置
     * @param index
     * @param element
     * @return
     */
    public int set(int index, E element){
        indexOutOfBoundsExceptioni(index);
        add(index,element);
        return -1;
    }

    /**
     * 添加元素到指定位置
     * @param index
     * @param element
     */
    public void add(int index, E element){
        changeCapaticy();//扩容或者缩容
        indexOutOfBoundsExceptioni(index);//判断索引是否越界
        for (int i=size;i>index;i--){
            elements[i] = elements[i-1];
        }
        elements[index] = element;
        size++;
    }



    /**
     * size为0的时候,直接将所有索引清除
     */
    public void clear(){
        for (int i=0;i<size;i++){//释放原数据
            elements[i] = null;
        }
        size = 0;
    }


    /**
     * 删除元素
     * @param element
     * @return
     */
    public int remove(E element){
        //查找元素所在位置
        int index = indexOf(element);
        if (index  == ELEMENT_NOT_FOND){
            return ELEMENT_NOT_FOND;
        }
        //删除元素
        removeOfIndex(index);
        return index;
    }

    /**
     * 获取元素索引
     * @param element
     * @return
     * equals默认比较的是地址, 重写后比较的是对象中自定义的内容
     * 可以保存null元素
     */
    public int indexOf(E element){
        if (element == null){
            for (int i=0;i<size;i++){
                if (elements[i] == null){
                    return i;
                }
            }
        }else{
            for (int i=0;i<size;i++){
                if (element.equals(elements[i])){
                    return i;
                }
            }
            
        }
        return ELEMENT_NOT_FOND;
    }

    /**
     * 扩容获取缩容
     */
    private void changeCapaticy(){
        if (size+1 == CAPATICY){
            CAPATICY += 10;
            System.out.println("扩容:"+CAPATICY+",size:"+size);
        }else{
            return;
        }
        E[] temps = (E[]) new Object[CAPATICY];
        for (int i=0;i<size;i++){
            temps[i] = elements[i];
        }
        elements = temps;
    }


    /**
     * 判断索引是否合法 -> 内部使用
     * @param index
     */
    private void indexOutOfBoundsExceptioni(int index){
        if (index < 0 || index > size){
            throw new IndexOutOfBoundsException("index:"+index+",Size:"+size);
        }
    }


    /**
     * 删除指定索引的元素
     * @param index
     */
    public void removeOfIndex(int index){
        indexOutOfBoundsExceptioni(index);
        for (int i=index;i<size;i++){
            elements[i] = elements[i+1];
        }
        elements[size--] = null;
    }


    /**
     * 打印内容
     */
    public void printElements(){
        String str = "[";
        for (int i=0;i<size;i++){
//            System.out.println(elements[i]+"");
            if (i == size-1){
                str += elements[i]+"";
            }else{
                str = str+elements[i]+",";
            }
        }
        str += "]";
        System.out.println(str);
    }
}