JAVA数据结构--ArrayList动态数组

在计算机科学中，动态数组，可扩展数组，可调整数组，动态表，可变数组或数组列表是一种随机存取可变大小列表数据结构，允许添加或删除元素。它提供许多现代主流编程语言的标准库。动态数组克服了静态数组的限制，静态数组具有需要在分配时指定的固定容量。

动态数组与动态分配的数组不同，数组是数组分配时大小固定的数组，尽管动态数组可能使用固定大小的数组作为后端。

　　

　　代码实现：

 package DataStructures;

 import java.util.Iterator;
 import java.util.NoSuchElementException;

 public class MyArrayList<AnyType> implements Iterable<AnyType> {

     private static final int DEFAULT_CAPACITY=10;
     private int theSize;
     private AnyType[] theItems;
     public MyArrayList() {
         doClear();
         // TODO Auto-generated constructor stub
     }
     private void clear(){
         doClear();
     }
     private void doClear(){    //移除动态数组中所有元素
         theSize=0;
         ensureCapacity(DEFAULT_CAPACITY);
     }
     public int size(){    //返回当前动态数组大小
         return theSize;
     }
     public boolean isEmpty(){
         return size()==0;
     }
     public void trimToSize(){    //将动态数组的容量调整为当前实例的大小
         ensureCapacity(size());
     }
     public AnyType get(int idx){
         if(idx<0||idx>=size())
             throw new ArrayIndexOutOfBoundsException();
         return theItems[idx];
     }
     public AnyType set(int idx,AnyType newVal){
         if(idx<0||idx>=size())
             throw new ArrayIndexOutOfBoundsException();
         AnyType old =theItems[idx];
         theItems[idx]=newVal;
         return old;
     }
     private void ensureCapacity(int newCapacity) {    //为当前的动态数组扩容
         if(newCapacity<theSize)
             return;
         AnyType[] old=theItems;
         theItems=(AnyType []) new Object[newCapacity];
         for(int i=0;i<size();i++)
             theItems[i]=old[i];
     }
     public boolean add(AnyType x){
         add(size(),x);
         return true;
     }
     public void add(int idx,AnyType x){    //添加数据
         if(theItems.length==size())
             ensureCapacity(size()*2+1);    //进行扩容
         for(int i=theSize;i>idx;i--){
             theItems[i]=theItems[i-1];
         }
         theItems[idx]=x;
         theSize++;
     }
     public AnyType remove(int idx){
         AnyType removeItem=theItems[idx];
         for(int i=idx;i<size()-1;i++)
             theItems[i]=theItems[i+1];
         theSize--;
         return removeItem;
     }
     @Override
     public Iterator<AnyType> iterator() {    //迭代器iterator方法返回的是ArrayListIterator的一个实例
         // TODO Auto-generated method stub
         return new ArrayListIterator();
     }
     private class ArrayListIterator implements Iterator<AnyType>{
         private int current=0;
         public boolean hasNext(){
             return current<size();
         }
         public AnyType next(){
             if(!hasNext())
                 throw new NoSuchElementException();
             return theItems[current++];
         }
         public void remove(){
             MyArrayList.this.remove(--current);
         }
     }
 }