ArrayList的实现

public class MyArrayList<T> {

    /** 声明一个对象数组 */
    private Object[] elements;

    /*** 数组的实际大小 */
    private int size = 0;

    /**
     * 创建arraylist
     *
     * @param initCapacity
     *            用户给定的初始容量
     */
    public MyArrayList1(int initCapacity) {
        if (initCapacity < 0) {
            throw new IllegalArgumentException("初始容量不能为负!");
        }
        elements = new Object[initCapacity];
    }

    /**
     * 创建ArrayList,无参,默认初始容量为16
     */
    public MyArrayList1() {
        this(16);
    }

    /**
     * 根据id查找元素
     *
     * @param index
     * @return
     */
    public Object findElementById(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("索引越界: " + index);
        }

        return elements[index];
    }

    /**
     * 根据元素查找id
     *
     * @param obj
     * @return
     */
    public int findIndexByElement(T obj) {
        for (int i = 0; i < size; i++) {
            if (obj.equals(elements[i])) {
                return i;
            }
        }

        // 没有这个元素,就返回-1
        return -1;
    }

    /**
     * 添加元素
     * @param obj
     */
    public void addElement(T obj) {
        incrementCapacity();
        elements[size] = obj;
        size++;
    }

    /***
     *  扩充容量
     */
    private void incrementCapacity() {
        if (size >= elements.length) {
            //扩充为原来的两倍: 2*size
            Object[] temp = new Object[2 * size];
            System.arraycopy(elements, 0, temp, 0, size);
            elements = temp;
        }
    }

    /**
     *  在指定位置增加元素
     * @param index
     * @param value
     */
    public void insertAt(int index,T value){
        if(index<0 || index >= size){
            throw new IllegalArgumentException("索引越界: "+index);
        }
        
        //创建一个新的数组(temp),将原来的元素从index开始,复制到新数组里去
        Object[] temp = new Object[size+1];
        System.arraycopy(elements, index, temp, index+1, size - index);
        
        //将原数组的index位置的元素设置为新值
        elements[index] = value;
        
        //将原数组的前半部分也复制到新数组(temp)去
        System.arraycopy(elements, 0, temp, 0, index+1);
        elements = temp;
        size++;
    }
    
    /**
     *  删除指定位置的元素
     * @param index
     */
    public void deleteElementAt(int index){
        if(index<0 || index >= size){
            throw new IllegalArgumentException("索引越界: "+index);
        }
        
        for (int i = index; i < size - 1; i++) {
            elements[i] = elements[i+1];
        }
        
        elements[size] = null;
        size--;
    }

    /**
     *  根据id替换值
     * @param index
     * @param value
     */
    public void updateElement(int index,T value){
        if(index<0 || index >= size){
            throw new IllegalArgumentException("索引越界: "+index);
        }
        
        elements[index] = value;
    }
    
    /**
     *  用新值替换旧值
     * @param original
     * @param newValue
     */
    public void replaceElementWithNewElement(T original,T newValue){
        int index = findIndexByElement(original);
        if(index<0){
            throw new RuntimeException("没有这个元素");
        }
        
        elements[index] = newValue;
    }
    /**
     * 打印输出
     */
    public String toString() {
        StringBuilder sb = new StringBuilder(2 * size + 1);
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(elements[i]);
            if (i != size - 1) {
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    /**
     * 返回集合大小
     * @return
     */
    public int getSize(){
        return size;
    }
    
    /**
     * 清空当前集合
     */
    public void clear(){
        elements = new Object[0];
        size = 0;
    }
}