Java 通用容器类和总结（一）：抽象容器类

1. 通过继承抽象类，自定义的类也可以更为容易地实现容器接口，为什么需要实现容器接口呢

• 容器类是一个大家庭，它们之间可以方便地协作，比如很多方法的参数和返回值都是容器接口对象，实现了容器接口，就可以方便地参与这种协作
• Java 有一个类 Collection，提供了很多针对容器接口的通用算法和功能，实现了容器接口，可以直接利用 Collection 中的算法和功能
• 除了接口中的方法，Collection 接口文档建议，每个 Collection 接口的实现类都应该提供至少两个标准的构造方法：一个是默认构造方法，一个是接受一个 Colleciton 类型的参数

2. 通过继承 AbstractCollection 来实现一个自定义容器

1. 第一步，使用之前实现的自定义动态数组容器类 DynamicArray 来实现一个简单的 Collection

   //给 DynamicArray 增加根据索引添加和删除的方法
   public class DynamicArray<E> {
       //...
       public void add(int index, E element) {
           ensureCapacity(size + 1);
           System.arraycopy(elementData, index, elementData, index + 1, size - index);
           elementData(index) = element;
           size++;
       }
       
       public E remove (int index) {
           E oldValue = get(index);
           int numMoved = size - index - 1;
           if(numMoved > 0) {
               System.arraycopy(elementData, index + 1, elementData, index, numMoved);
               elementData[--size] = null;
               return oldValue;
           }
       }
   }

2. 第二步，基于 DynamicArray，实现一个简单的迭代器类 DynamicArrayIterator

   //一个简单的迭代器类 DynamicArrayIterator
   public class DynamicArrayIterator<E> implements Iterator<E> {
       DynamicArray<E> darr;
       int cursor;
       int lastRet = -1;
       
       public DynamicArrayIterator(DynamicArray<E> darr) {
           this.darr = darr;
       }
       
       @Override
       public boolean hasNext() {
           return cursor != darr.size();
       }
       
       @Override
       public E next() {
           int i = cursor;
           if(i >= darr.size()) {
               throw new NuSuchElementException();
           }
           cursor = i + 1;
           lastRet = i;
           return darr.get(i);
       }
       
       @Override
       public void remove() {
           if(lastRet < 0) {
               throw new IllegalStateException();
           }
           darr.remove(lastRet);
           cursor = lastRet;
           lastRet = -1;
       }
   }

3. 第三步：基于 DynamicArray 和 DynamicArrayIterator，通过继承 AbstractionCollection 实现一个简单的容器类 MyCollection

   //一个简单的容器类 MyCollection
   public class MyCollection<E> extends AbstractCollection<E> {
       DynamicArray<E> darr;
       
       public MyCollection() {
           this();
           addAll(c);
       }
       
       @Override
       public Iterator<E> iterator() {
           return new DynamicArrayIterator<> (darr);
       }
       
       @Override
       public int size() {
           return darr.size();
       }
       
       @Override
       public boolean add(E e) {
           darr.add(e);
           return true;
       }
   }