java源码(5) -- java.util.AbstractCollection

我也不知道看源码有什么用，就是想去看看

AbstractCollection是一个抽象类，实现了java.util.Collection接口.

此类提供了Collection接口的骨干实现，以最大限度地减少实现此接口所需的工作.

下面来具体看看源代码是怎么实现的

package java.util;

public abstract class AbstractCollection<E> implements Collection<E> {

   private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

   //构造函数
   protected AbstractCollection() {
     //唯一的构造方法(由子类构造方法调用,通常是隐式调用)
   }

   /*操作元素集合的方法*/
   //将元素e添加到该集合中
   //从源码中可以看到该方法的实现直接抛出一个异常,需要其子类来重写该方法
   public boolean add(E e) {
      throw new UnsupportedOperationException();
    }
    
   //将指定集合c中的所有元素都添加到此集合中
   public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }


    //从此集合中移除指定元素o
    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; 
    }

    //移除集合中那些也包含在指定集合c中的所有元素
    public boolean removeAll(Collection<?> c) {
        boolean modified = false;
        Iterator<?> 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();
        }
    }


   /*查询集合元素的方法*/ 
   //返回此集合中的元素个数,如果此集合包含的元素个数大于Integer.MAX_VALUE,则返回Integer.MAX_VALUE
   public abstract int size();
 
   //判断集合中是否有元素,从源码中可以看到如果size()方法返回0则返回true,   否则返回false
   public boolean isEmpty(){
      return size() == 0;
   }        

   //判断元素o是否在该集合中
   //从源码中可以看出,此方法实现是在集合中的元素上进行迭代,并以此检    查每个元素以确定其是否与指定元素o相等
   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;
    }
   
    //如果此集合包含指定的集合c中的所有元素,则返回true
    public boolean retainAll(Collection<?> c) {
        boolean modified = false;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            if (!c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }


    //如果此集合包含指定的集合c中的全部元素,则返回true
    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }
    
  /*其他方法*/
  //返回该集合的迭代器对象
  public abstract Iterator<E> iterator();

  //返回包含此集合中所有元素的数组
  //此方法充当了基于数组的API和基于collection的API之间的桥梁
  public Object[] toArray(){
    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;
  }
  
      public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        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()) { // fewer elements than expected
                if (a != r)
                    return Arrays.copyOf(r, i);
                r[i] = null; // null-terminate
                return r;
            }
            r[i] = (T)it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

   private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            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();
        }
        // trim if overallocated
        return (i == r.length) ? r : Arrays.copyOf(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 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(' ');
        }
    }
}