public abstract class <E> implements Collection<E> {
  
  protect () {}
  public abstract Iterator<E> iterator();
  public abstract int size();
  public boolean isEmpty() {
    return size() == 0;
  }
  /* 判断是否包含某个对象，这个函数肯定是可以通用的，所以直接在抽象类里面实现了,
    这里都是把 null 和不为 null 的值分开处理的，在后面也可以看到很多这种情况，
    主要是考虑到 o.equals()会抛 nullpoint 异常。但是为什么不使用 it.next().equals(o)
    来代替呢？因为列表里是有可能存一个 null 的值的，比如[1, 2, 3, null, 5, 6]，这时候
    使用 it.next().equals(o) 依然会出现 nullpoint */
  public boolean contains(Object o) {
    Iterator<E> it = iterator();
    if (o == null) {
      while (it.hasNext())
        if (it.next() == null) 
          return true;
    } else {
      while (it.hasNext())
        if (o.equals(it.next()))
          return true;
    }
    return false;
    }

    /* 返回一个包含了这个集合中所有元素的数组，数组中元素的顺序和集合中元素的顺序相同。，
    即使在迭代的过程中数组的长度被扩充（当集合被几个线程并行修改的时候，长度是非常有可能会被扩充的），最终返回的数组的长度与 iterator 中元素的个数相同。
    如果集合中的元素比预期的少，则调用 Arrays.copyOf() 方法将数组的元素复制到新数组中，并返回新数组
    如果集合中的元素比渔区的多，在调用 finishToArray() 方法生成新的数组，并返回新数组
     */
    public Object[] toArray() {
      // 这里调用 size() 方法只是对这个数组的长度做一个预估，实际上有可能会被自动扩充
      Object[] r = new Object[size()];
      Iterator<E> it = iterator();
      for (int i = 0; i < r.length; i++) {
        if (! it.hasNext())
          return Arrays.copyOf(r, i);
        r[i] = it.next();
      }
      return it.hasNext() ? finishToArray(r, it) : r;
    }
    /* 数组可以扩容的最大值，实际上在Java中，数组的最大长度是 Integer.MAX_VALUE-2，
      为了防止内存溢出，在这里就做了 Integer.MAX_VALUE-8 这样的一个限制
      关于为什么最大长度要减去 8，Java官方的解释是：对于有些虚拟机实现来说，数组对象的头部会占用这 8 个字节 */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /* 给数组扩容 */
    ("unchecked")
    private static <T> T[] finishArray(T[] r, Iterator<?> it) {
      int i = r.length;
      while (it.hasNext()) {
        int cap = r.length;
        // 当数组索引指向最后一个元素时，对数组进行扩容，扩容大小：cap + cap/2 + 1
        if (i == cap) {
          int newCap = cap + (cap >> 1) + 1;
          // overflow - conscious code, 扩容之前需要判断数组长度是否溢出
          if (newCap - MAX_ARRAY_SIZE > 0)
            newCap = hugeCapacity(cap + 1);
          r = Arrays.copyOf(r, newCap);
        }
        r[i++] = (T)it.next();
      }
      return (i == r.length) ? r : Arrays.cofyOf(r, i);
    }
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError
                ("Required array size too large");
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    /* 返回指定类型的数组 */
    public <T> T[] toArray(T[] a) {
      int size = size();
      // 如果传入数组的长度大于等于集合的长度，则将当前集合的元素复制到传入的数组中
      // 如果传入的数组的长度小于集合的大小，则将创建要给新的数组来进行集合元素的存储
      T[] r = a.length >= size ? a : (T[])java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size());
      Iterator<E> it = iterator();
      for (int i = 0; i < r.length; i++) {
        if (! it.hasNext()) {
          // 如果数组时参数中的数组，则将剩余部分的值都设置为 null
          if (a == r) {
            r[i] = null;
          } else if (a.length < i) {
            // 如果传入的数组长度小余集合，则通过 Arrays.copyOf 将之前数组中的元素复制到新数组中
            return Arrays.copyOf(r, i);
          } else {
            // 如果传入数组的长度比集合大，则将多的元素设置为 null
            System.arraycopy(r, 0, a, 0, i);
            if (a.length > i) {
              a[i] = null;
            }
          }
          return a;
        }
        r[i] = (T) it.next()
      }
      return it.hasNext() ? finishToArray(r, it) : r;
    }

    // Collection 不支持 add 操作
    public boolean add(E e) {
      throw new UnsupportedOperationException();
    }
    // 删除元素，这里 null 值依旧需要特殊处理，因为有 o.equals()
    public boolean remove(Object o) {
      Iterator<E> it = iterator();
      if (o == null) {
        while(it.hasNext()) {
          if (it.next == null) 
            it.remove();
            return true;
        }
      } else {
        while (it.hasNext()) {
          if (o.equals(it.next())) {
            it.remove();
            return true;
          }
        }
      }
      return false;
    }

    public boolean containsAll(Collection<?> c) {
      for (Object e : c) 
        if (!contains(e))
          return false;
      return true;
    }


  // this implementation iterates over the specified collection, and adds each
  // object returned by the iterator to this colection, in return
  public boolean addAll(Collection<? extends E> c) {
    boolean modified = false;
    if (E e : c)
      if (add(e))
        modified = true;
    return modified;
  }

  public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    boolean modified = false;
    Iterator<?> it = iterator();
    while (it.hasNext()) {
      if (c.contains(it.next())) {
        it.remove();
        modified = true;
      }
    }
    return modified;
  }

  // This implementation iterates over this collection, checking each elements returned
  // by the iterator in turn to see if it's contained in the specified collection.
  // if it's not so contained, it's removed from this collection with the iterator's remove method
  public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    boolean modified = false;
    Iterator<E> it = iterator();
    while (it.hasNext()) {
      if (! c.contains(it.next())) {
        it.remove();
        modified = true;
      }
    }
    return modified;
  }
  // 删除集合里的所有元素
  public void clear() {
    Iterator<E> it = iterator();
    while (it.hasNext()) {
      it.next();
      it.remove();
    }
  }

  // Returns a string representation of this collection.
  public String toString() {
    Iterator<E> it = iterator();
    if (! it.hasNext())
      return "[]";
    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for(;;) {
      E e = it.next();
      sb.append(e == this ? "(this Collection)" : e);
      if (! it.hasNext())
        return sb.append(']').toString();
      sb.append('.').append(' ');
    }
  }
}