集合框架源码分析——抽象类

public abstract class AbstractCollection<E> implements Collection<E> {
    /**
     * 唯一构造方法
     */
    protected AbstractCollection() {
    }


    // Query Operations


    /**
     *
     * 返回集合中元素的迭代器
     */
    public abstract Iterator<E> iterator();


    public abstract int size();


    public boolean isEmpty() {
return size() == 0;   //size=0则此方法返回true
    }


    public boolean contains(Object o) {
Iterator<E> e = iterator();   //获取此集合的迭代器
if (o==null) {               
   while (e.hasNext())      
if (e.next()==null)   //如果此集合允许null元素，找到则返回true
   return true;
} else {
   while (e.hasNext())
if (o.equals(e.next()))
   return true;
}
return false;
    }


    /**
     * 此方法是同步的，即使在遍历集合的过程中发现集合已经改变，任然可以返回
     * 正确的结果
     *
     * 此方法等同于:
     *
     * List<E> list = new ArrayList<E>(size());
     * for (E e : this)
     *     list.add(e);
     * return list.toArray();
     */
    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);  //则仅返回长度为i的数组，i=当前集合长度
   r[i] = it.next();
}
        //如果遍历完后发现集合还有更多的元素，即在遍历时有元素被添加进集合，调用
        //finishToArray方法添加剩余的元素
return it.hasNext() ? finishToArray(r, it) : r;
    }


   
    public <T> T[] toArray(T[] a) {
        int size = size();      //当前集合长度
        T[] r = a.length >= size ? a :  //如果a的长度大于等于size，把a赋给r，否则新建一个元素类型为a元素类型，size长度的数组
                  (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()) { 遍历过程中，集合中有元素被移除，长度减少.或遍历集合结束
if (a != r)   //表明是新建的数组
   return Arrays.copyOf(r, i);
r[i] = null; // 表明是a，则多加一个null结束符
return r;
   }
   r[i] = (T)it.next();
}
return it.hasNext() ? finishToArray(r, it) : r;
    }


    /**
     * 当it还有更多的元素，重新分配数组。并把剩余元素添加进数组
     */
    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
int i = r.length;         //原来数组长度存入i中
while (it.hasNext()) {
int cap = r.length;   
if (i == cap) {   //表明未重新分配数组长度
int newCap = ((cap / 2) + 1) * 3;   //新数组长度的计算公式，大约扩充1.5倍
if (newCap <= cap) { // 如果分配后发生了整型溢出
if (cap == Integer.MAX_VALUE)
throw new OutOfMemoryError("Required array size too large");
newCap = Integer.MAX_VALUE;    
}
r = Arrays.copyOf(r, newCap); //新建一个长度为newCap的数组，并把r中数据存入
}
r[i++] = (T) it.next();   //添加集合剩余元素到新数组
}
// 修剪多余的长度
return (i == r.length) ? r : Arrays.copyOf(r, i);
}


    // Modification Operations


    /**
     * 调用此方法总是抛出一个异常，需要子类去重写此方法
     */
    public boolean add(E e) {
throw new UnsupportedOperationException();
    }


    /**
     * 此方法会首先在集合中查找指定元素o，如果找到就移除它
     * 移除的是第一个找到的匹配的值
     */
    public boolean remove(Object o) {
Iterator<E> e = iterator();
if (o==null) {       //集合支持null元素
   while (e.hasNext()) {
if (e.next()==null) {
   e.remove();     
   return true;
}
   }
} else {
   while (e.hasNext()) {
if (o.equals(e.next())) {
   e.remove();
   return true;
}
   }
}
return false;
    }




    // Bulk Operations


   
    public boolean containsAll(Collection<?> c) {
Iterator<?> e = c.iterator();
while (e.hasNext())
   if (!contains(e.next()))  //如果c中有一个元素不在本集合中则返回false
return false;
return true;
    }


    /**
     * 此方法将抛出一个UnsupportedOperationException，除非子类重写了add方法
     */
    public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
Iterator<? extends E> e = c.iterator();
while (e.hasNext()) {
if (add(e.next()))   //如果有一个元素添加失败就返回false
modified = true;
}
return modified;
    }




    public boolean removeAll(Collection<?> c) {
boolean modified = false;
Iterator<?> e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) { //如果c中元素也保含在本集合中则移除它
e.remove();
modified = true;
}
}
return modified;
}


   public boolean retainAll(Collection<?> c) {
boolean modified = false;
Iterator<E> e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) {  //遍历集合元素，如果元素不包含在c中，则移除此元素
e.remove();               //取的是交集
modified = true;
}
}
return modified;
}




    public void clear() {
Iterator<E> e = iterator();
while (e.hasNext()) {    //依次调用next和remove方法
   e.next();
   e.remove();
}
    }




    //  String conversion


   /**
* 重写toString方法,返回格式：[e.toString, e2.toString, ...]
* */
public String toString() {
Iterator<E> i = iterator();
if (!i.hasNext())   //如果集合为空返回[]
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = i.next();
sb.append(e == this ? "(this Collection)" : e);
if (!i.hasNext())
return sb.append(']').toString();
sb.append(", ");
}
}


}