数据结构之--单链表MyArrayList

仿照Java集合类库中的ArrayList，自己手动写了一个MyArrayList，内部使用一个数组来维护。具体的adt描述如下

isEmpty()　　　　判断是否为空

size()　　　　　　获取当前存储的元素个数

clear()　　　　　清空当前的所有元素

set(idx, e)　　　　重置指定位置的元素

ensureCapacity(newCapacity)　　指定底层数组的大小

add(e)　　　　　　添加一个元素，默认在尾部

add(idx, e)　　　　在指定位置添加一个元素

remove(idx)　　　　删除指定位置的元素

iterator()　　　　　　返回相应的迭代器

/**
 * 手写的一个MyArraylist实现ArrayList的常规操作，并且也实现了迭代器
 * 实现迭代器操作，必须要实现Iteratable接口
 * @author Administrator
 *
 * @param <AnyType> 手写的这个顺序表支持泛型
 */
public class MyArrayList<AnyType> implements Iterable<AnyType>{
    private static final int DEFAULT_CAPACITY = 10;    //默认的 大小为 10
    
    private int thisSize ;    // 当前已经存入的元素的个数
    private AnyType[] theItems;    //定义一个数组用来存储元素, 而且是一种懒汉模式来维护的
    
    public MyArrayList(){
        clear();
    }
    
    /**
     * 清空这个链表
     */
    public void clear()
    {
        thisSize = 0;
        ensureCapacity(DEFAULT_CAPACITY);
    }
    
    public int size(){
        return thisSize;
    }
    public boolean isEmpty()
    {
        return size()==0;    // 当thisSize==0说明为空链表
    }
    public void trimToSize()
    {
        ensureCapacity(size());
    }
    
    public AnyType get(int idx)
    {
        if(idx < 0 || idx >= size())
            throw new ArrayIndexOutOfBoundsException();    //    抛出数组越界的异常
        return theItems[ idx ];
    }
    /*
     * 重置指定位置idx处的元素 为 newVal
     */
    public AnyType set(int idx, AnyType newVal)
    {
        if(idx <= 0 || idx >= size())
            throw new ArrayIndexOutOfBoundsException();
        AnyType old = theItems[ idx ];
        theItems[idx] = newVal;
        return old;
    }
    
    public void ensureCapacity( int newCapacity )
    {
        if(newCapacity < thisSize)// 不需要 修改数组的大小
            return ;
        
        AnyType[] old = theItems;    //先把原来的数组记录下来
//        theItems = new AnyType[newCapacity]; 注意了 不能这样创建一个泛型的数组 向下面那样操作就行了
        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);    //一旦size不够 就扩容两倍
        // 先把 [idx, size]的元素向后移动
        for(int i = thisSize; i > idx; i--)// 为什么 不是 i = thisSieze - 1; 因为初始 thisSize=0的时候 会出现数组越界的情况
            theItems[i] = theItems[i-1];
        theItems[idx] = x;
        thisSize ++;
    }
    
    public AnyType remove(int idx)
    {
        if(idx <= 0 || idx > size())
            throw new ArrayIndexOutOfBoundsException();
        AnyType removeItem = theItems[idx-1];
        // 吧[idx+1, size]元素想做移动1
        for(int i = idx-1; i < size(); i++)
            theItems[i] = theItems[i+1];
        
        thisSize --;
        return removeItem;
    }
    
    
    @Override
    public Iterator<AnyType> iterator() {
        return new MyArrayListIterator();
    }
    
    // 内部类的形式 定义一个自己的 迭代器  内部类 可以方便的访问 外部类的 数据成员
    private class MyArrayListIterator implements Iterator<AnyType>
    {
        private int current = 0;
        
        @Override
        public boolean hasNext() {
            return current < size();
        }

        @Override
        public AnyType next() {
            if(!hasNext())
                throw new NoSuchElementException();
            
            return theItems[current++];
        }

        @Override
        public void remove() {
            MyArrayList.this.remove(--current);    // 创建调用内部类的方法
        }
        
    }
    
    public static void main(String[] args) {
        MyArrayList<Integer> list = new MyArrayList<Integer>();
        
        System.out.println(list.isEmpty());
        System.out.println(list.size());
        
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list.isEmpty());
        System.out.println(list.size());
        
        System.out.println(list.remove(2));
        
        System.out.println(list.size());
        
        Iterator<Integer> it = list.iterator();
        while(it.hasNext())
            System.out.print(it.next()+", ");
        System.out.println();
    }

}

 line103~line130其实是很有内容的，这里把ArrayListIterator定义成了一个内部类。

private class ArrayListIterator implements Iterator<AnyType>{

　　private int current = 0;

　　public boolean hasNext()

　　{return current < size()}　　//current < MyArrayList.this.size()

　　………………

　　public void remove()

　　{MyArraylList.this.remove(--current);}　　// 为了消除歧义，就不能简写了

},

上面其实都是内部类（Internal class），内部类里面可以直接访问外部类的属性和方法，其实在内部类中调用外部类的方法和属性时，实际上应当是带上外部类的一个引用比如应当是current < MyArrayList.this.size(),内部类的一大好处是允许程序员简写成current < size(),简写的前提是内部类和外部类没有回引起歧义的同名方法或者同名属性，如果会引起歧义时就不能再简写了，比如下面的 remove方法，内部类ArrayListIterator和外部类MyArrayList都有这个方法，那么在内部类总调用外部类的remove方法时，就不能简写了，应当写成MyArrayList.this.remove(--current);

private static class ArrayListIterator implements Iterator<AnyType>{

}

这种定义情况和上一中乍一看差不多，只是多了一个static关键字而已，这时ArrayListIterator就不在是一个内部类，摇身一变成了一个嵌套类（Nest额的 Class）。嵌套类因为是一个static的，只能访问被嵌套类中的静态属性和静态方法。