自定义类,实现ArrayList基本功能

import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class CreatArrayList<E> {
    /** 数据将被存储在里面*/
    private transient Object[] elementData;

    /**CreatArrayList里面的元素的个数*/
     private int size;

    /**
     * CreatArrayList的最大的容器的大小
     */
     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

     /**
      *这个就用多线程的判断
      */
      protected transient int modCount = 0;

     /**
      * 构造一个空的且初始化其大小的 CreatArrayList
      */
     public CreatArrayList(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }
     /**
      * 默认的CreatArrayList的初始化大小
      */
      public CreatArrayList() {
            this(10);
        }
     /**
      * 增加一个元素在CreatArrayList 的最末尾
      */
      public boolean add(E e) {
          ensureCapacity(size + 1);    //第一步首先判断是否要扩容,如果扩容就会进一步操作
           elementData[size++] = e;
          return true;
      }
     /**
      * 检查是否要扩容
      * 判断标准：增加一个元素后的大小minCapacity(size+1)
      * 其实就是增加一个元素后，元素的个数是是否超过容器的大小
      * 
      */
      private void ensureCapacity(int minCapacity){
          if (minCapacity - elementData.length > 0)
              growCapacity(minCapacity);
      }
      /**
       * 对CreatArrayList进行扩容,传入的参数是元素的个数，其实就是容器最小的个数
       */
      private void growCapacity(int minCapacity){
          int oldCapacity=elementData.length;
          int newCapacity=oldCapacity+(oldCapacity>>1);
           if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
           if (newCapacity - MAX_ARRAY_SIZE > 0)//如果已下子扩的太大,那么就等于
               newCapacity = hugeCapacity(minCapacity);

           //把旧的容器里面的数据复制到新的容器大小为（newCapacity）里面,并且返回新的数据
           elementData = Arrays.copyOf(elementData, newCapacity);
      }
    /**
     *  这个其实也就是当newCapacity>大于MAX_ARRAY_SIZE的时候
     *  那么就会判断数据的大小minCapacity
     *  如果minCapacity>MAX_ARRAY_SIZE  那么只增加8个大小,也就是Integer.MAX_VALUE 
     *  minCapacity
      private static int hugeCapacity(int minCapacity) {
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
        }

      /**
       * 删除指定位置的元素
       */
     @SuppressWarnings("unchecked")
    public  E remove(int index) {
         rangeCheck(index);
          E oldValue =(E) elementData[index];
          int numMoved = size - index - 1;    //多少个元素需要移动
           if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
           elementData[--size] = null; // Let gc do its work
           return oldValue;
     }
     /**
      *检测要移除的元素的索引是否合理
      */
     private void rangeCheck(int index) {
            if (index >= size)
                new Exception("数组越界");
     }
     /**
      * 创建一个基本的内部类用于进行迭代
      */
    public Iterator iterator() {
            return  new CreatItr();
        }
     /**
      * 内部类
      * */
     private class CreatItr implements Iterator<E>  {
           int cursor;       // index of next element to return
            int lastRet = -1; // index of last element returned; -1 if no such
            int expectedModCount = modCount;
        public boolean hasNext() {
            return cursor!=size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
              int i = cursor;
                if (i >= size)
                    throw new NoSuchElementException();
                Object[] elementData = CreatArrayList.this.elementData;
                if (i >= elementData.length)
                    throw new ConcurrentModificationException();
                cursor = i + 1;
                return (E) elementData[lastRet = i];
        }

         /**
          * 判断线程是否出问题
          * 这个就是为什么在迭代过程中间删除元素会抛出异常的原因
          */
           @SuppressWarnings("unused")
        final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }

        @Override
        public void remove() {
            // TODO Auto-generated method stub

        }
     }
}

---

---

简单 测试自己写的集合

import java.util.Iterator;

public class Test1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        CreatArrayList creatList=new CreatArrayList();
        creatList.add("1");
        creatList.add("2");
        creatList.add("3");
        creatList.add("4");
        creatList.add("5");
        Iterator tir=creatList.iterator();
        while(tir.hasNext()){
            System.out.print(tir.next());
        }
    }

}