public class arraylist<E> {
  /**
   * 存放集合的元素 
   * 
   */
  private transient Object[] elementData;
  /** 元素的大小 */
  private int size;

/**
   * 根據(jù)指定大小初始化
   * @param initialCapacity
   */
  public arraylist(int initialCapacity){
    super();
    if(initialCapacity<=0){
      //拋異常
      throw new IllegalArgumentException("初始化參數(shù)不能小于0");
    }else{
      //初始化數(shù)組
      this.elementData=new Object[initialCapacity];
    }
  }
  /**
   * 默認初始化
   */
  public arraylist(){
    this(10);
  }
  /**
   * 根據(jù)一個集合類初始化
   * @param c 一個必須繼承了Collection接口的類
   */
  public arraylist(Collection<? extends E> c){
    //初始化
    elementData=c.toArray();
    size=elementData.length;
    //如果不是任意類型的數(shù)組就轉換Objec類型
    if (elementData.getClass() != Object[].class){
      elementData=Arrays.copyOf(elementData,size, Object[].class);
    }
  }

/**
   * 擴容集合
   * @param minCapacity
   */
  public void ensureCapacity(int minCapacity){
    /** 當前數(shù)組的大小 */
    int oldCapacity = elementData.length; 
    if (minCapacity > oldCapacity) {
      /**
       * oldData 雖然沒有被使用，但是這是關于內(nèi)存管理的原因和Arrays.copyOf()方法不是線程安全
       * oldData在if的生命周期內(nèi)引用elementData這個變量，所以不會被GC回收掉
       * 當Arrays.copyOf()方法在把elementData復制到newCapacity時，就可以防止新的內(nèi)存或是其他線程分配內(nèi)存是elementData內(nèi)存被侵占修改
       * 當結束是離開if，oldData周期就結束被回收
       */
      Object oldData[] = elementData; 
      int newCapacity = (oldCapacity * 3)/2 + 1; //增加50%+1
        if (newCapacity < minCapacity) 
          newCapacity = minCapacity; 
     //使用Arrays.copyOf把集合的元素復制并生成一個新的數(shù)組
     elementData = Arrays.copyOf(elementData, newCapacity); 
    } 
  }

 /**
   * 檢查索引是否出界
   * @param index
   */
  private void RangeCheck(int index){
    if(index > size || index < 0){
      throw new IndexOutOfBoundsException("下標超出,Index: " + index + ", Size: " +size);
    }
  }

* 添加元素
   * 將指定的元素添加到集合的末尾
   * @param e 添加的元素
   * @return
   */
  public boolean add(E e){
    ensureCapacity(size+1);
    elementData[size]=e;
    size++;
    return true;
  }

/**
   * 添加元素
   * 將元素添加到指定的位置
   * @param index 指定的索引下標
   * @param element 元素
   * @return
   */
  public boolean add(int index, E element){
    RangeCheck(index);
    ensureCapacity(size+1);
    // 將 elementData中從Index位置開始、長度為size-index的元素， 
    // 拷貝到從下標為index+1位置開始的新的elementData數(shù)組中。 
    // 即將當前位于該位置的元素以及所有后續(xù)元素右移一個位置。
    System.arraycopy(elementData, index, elementData, index+1, size-index);
    elementData[index]=element;
    size++;//元素加一
    return true;
  }

/**
   * 添加全部元素
   * 按照指定collection的迭代器所返回的元素順序，將該collection中的所有元素添加到此列表的尾部。 
   * @param c
   * @return
   */
  public boolean addAll(Collection < ? extends E>c){
    Object[] newElement=c.toArray();
    int elementLength=newElement.length;
    ensureCapacity(size+elementLength);
    //從newElement 0的下標開始，elementLength個元素，elementData size的下標 
    System.arraycopy(newElement, 0, elementData, size, elementLength);
    size+=elementLength;
    return elementLength!=0;
  }

/**
   * 指定位置，添加全部元素
   * @param index 插入位置的下標
   * @param c 插入的元素集合
   * @return
   */
  public boolean addAll(int index, Collection<? extends E> c){
    if(index > size || index < 0){
      throw new IndexOutOfBoundsException("Index: " + index + ", Size: " +size);
    }
    Object[] newElement=c.toArray();
    int elementLength=newElement.length;
    ensureCapacity(size+elementLength);
    int numMoved=size-index;
    //判斷插入的位置是否在數(shù)組中間
    if(numMoved>0){
      //把index插入位置的后面的所有元素往后移
      //elementData index下標開始的numMoved個元素插入到elementData 的index+elementLength位置
      System.arraycopy(elementData, index, elementData, index+elementLength, numMoved);
    }
    //把newElement里從0開始的elementLength個元素添加到elementData index開始的位置
    System.arraycopy(newElement, 0, elementData, index, elementLength); 
    size += elementLength; 
    return elementLength != 0;
  }
  
  /**
   * 指定下標賦值
   * @param index
   * @param element
   * @return
   */
  public E set(int index,E element){
    RangeCheck(index);
    E oldElement=(E)elementData[index];
    elementData[index]=element;
    return oldElement;
  }
  
  /**
   * 根據(jù)下標取值
   * @param index
   * @return
   */
  public E get(int index){
    RangeCheck(index);
    return (E)elementData[index];
  }
  
  /**
   * 根據(jù)下標移除元素
   * @param index 
   */
  public E remove(int index){
    RangeCheck(index);
    E oldElement=(E)elementData[index];
    /** 移除的下標后面的元素數(shù)量 */
    int numMoved=size-index-1;
    //如果在數(shù)組范圍內(nèi)就進行移動
    if(numMoved>0)
      System.arraycopy(elementData, index+1, elementData, index, numMoved);
    //移除
    elementData[--size]=null;
    return oldElement;
  }
  
  /**
   * 根據(jù)元素移除
   * @param obj
   * @return
   */
  public boolean remove(Object obj){
    //Arraylist允許存放null,所以也要進行判斷處理
    if(obj==null){
      for(int index=0;index<size;index++){
        if(elementData[index]==null){
           remove(index);
           return true;
        }
      }
    }else{
      for(int index=0;index<size;index++){
        if(obj.equals(elementData[index])){
           remove(index);
           return true;
        }
      }
    }
    return false;
  }
  
  /**
   * 根據(jù)下標移除指定范圍內(nèi)的元素
   * @param fromIndex 開始
   * @param toIndex 結束
   */
  protected void removeRange(int fromIndex, int toIndex){
    RangeCheck(fromIndex);
    RangeCheck(toIndex);
    //要移動的元素數(shù)
    int numMoved = size - toIndex; 
    //把toIndex后面的元素移動到fromIndex
    System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);
    //要移除的元素數(shù)量
    int newSize=size-(toIndex-fromIndex);
    while(size!=newSize){
      elementData[--size]=null;
    } 
  }
  
  /**
   * 把數(shù)組容量調整到實際的容量
   */
  public void trimToSize(){
    int leng=elementData.length;
    if(size<leng){
      Object[] old=elementData;
      elementData=Arrays.copyOf(elementData, size);
    }
  }
  /**
   * 把集合元素轉換成數(shù)組
   * @return
   */
  public Object[] toArray(){
    return Arrays.copyOf(elementData, size);
  }
  
  public <T>T[] toArray(T[] a){
    if(a.length<size){
      return (T[]) Arrays.copyOf(elementData,size, a.getClass());
    }
    //把集合元素復制到a數(shù)組中
    System.arraycopy(elementData, 0, a, 0, size);
     if (a.length > size){
       for(int index=size;index<a.length;index++){
         a[index] = null;
       }
     }
     return a; 
  }