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);
        }
    }
}