java的AbstractCollection源码分析

 

关键词 ： AbstractCollect    源码分析                                          

AbstractCollection 抽象类提供了 Collection 的骨架实现 ,Collection 分析请看 :
http://blog.csdn.net/treeroot/admin/Referrers.aspx?EntryID=99591
这里直接看它的代码是如何实现的 .
public abstract Iterator iterator();
该方法没有实现 .
public abstract int size();
该方法没有实现 .
public boolean isEmpty() {
 return size() == 0;
   }
非常简单 , 直接调用 size() 方法返回大小 , 如果是 0 就认为是空集合 .
你不会觉得奇怪吧 ,size() 方法没有实现 , 怎么可以调用呢 ? 因为这个是抽象类 , 不可以实例化的 , 具体的时候调用的是子类中的实现 .
public boolean contains(Object o) {
 Iterator e = iterator();
 if (o==null) {
     while (e.hasNext())
      if (e.next()==null)
          return true;
 } else {
     while (e.hasNext())
     if (o.equals(e.next()))
           return true;
 }
  return false;
}
代码不复杂 , 也是调用自己的方法 iterator, 遍历集合 , 如果找到了就返回 true, 在没找到的情况下是要遍历整个集合的 . 对于 null 值的情况一定要放在 if 里面 , 而不能放在 else 里面 .
public Object[] toArray() {
    Object[] result = new Object[size()];
    Iterator e = iterator();
    for (int i=0; e.hasNext(); i++)
         result[i] = e.next();
    return result;
  }
返回数组 , 先生成一个和集合一样大小的数组 , 然后通过遍历赋值 .
public Object[] toArray(Object a[]) {
        int size = size();
        if (a.length < size)
            a = (Object[])java.lang.reflect.Array.newInstance(
                                  a.getClass().getComponentType(), size);

        Iterator it=iterator();
        for (int i=0; i
            a[i] = it.next();

        if (a.length > size)
            a[size] = null;

        return a;
    }
这个方法如果在数组 a 比集合小的情况和上面是一样的 , 这种情况下生成了一个新的数组 , 这里用到了反射 ( 从字面上就可以看出意思 ). 为什么不可以直接 new 呢 ? 因为数组 a 中的元素是具有运行时类型的 , 而不仅仅是 Object. 可以看出当 a 可以容纳整个集合时是不用重新分配空间的 , 而且如果 a 比集合大 , 会设置 a[size] 为 null 值 , 而且仅仅设置了这一个 . 如果集合允许 null 值的话 , 通过返回数组是无法判断集合的大小的 , 因为可能集合的最后几个都是 null 值 .
public boolean add(Object o) {
      throw new UnsupportedOperationException();
    }
这个方法提供了实现 , 但是是直接抛出一个异常 , 和未实现的方法是有区别的 , 非抽象子类中可以不重写这个方法 , 如果子类不想支持这个操作的话 , 而未实现的方法子类必须实现 , 否则编译同不过 .
public boolean remove(Object o) {
  Iterator e = iterator();
 if (o==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;
}
这个方法和 contians 方法基本一样 , 多了一条 e.remove 语句而已 .
public boolean containsAll(Collection c) {
 Iterator e = c.iterator();
 while (e.hasNext())
     if(!contains(e.next()))
          return false;

 return true;
}
这个方法比较简洁 , 但是时间复杂度是 m*n, 通过检查没一个元素是否在集合中 , 如果发现一个不在直接返回 false. 可以看出返回 true 的情况花的时间比返回 false 要多 .
public boolean addAll(Collection c) {
 boolean modified = false;
 Iterator e = c.iterator();
 while (e.hasNext()) {
     if(add(e.next()))
        modified = true;
 }
 return modified;
}
这里是通过一个一个加入集合的 , 同样这里的 add 方法是没有实现的 , 要注意的一点是 , 只要加入了至少一个元素函数就返回 true, 表示原来的集合有变化 .
public boolean removeAll(Collection c) {
 boolean modified = false;
 Iterator e = iterator();
 while (e.hasNext()) {
     if(c.contains(e.next())) {
          e.remove();
          modified = true;
      }
 }
 return modified;
}
这个方法对集合中的每一个元素判断 , 如果在集合 c 中就删除 , 相同值的会被一并删除 , 删除至少一个元素就返回 true.
public boolean retainAll(Collection c) {
 boolean modified = false;
 Iterator e = iterator();
 while (e.hasNext()) {
     if(!c.contains(e.next())) {
         e.remove();
        modified = true;
     }
 }
 return modified;
}
这个方法和上面的几乎一样 , 多了一个非 (!).
public void clear() {
 Iterator e = iterator();
 while (e.hasNext()) {
     e.next();
     e.remove();
 }
}
这个方法把集合清空 , 不过这个方法效率显得比较低 , 清空应该不需要遍历集合 , 不过子类可以重写整个方法 .
public String toString() {
 StringBuffer buf = new StringBuffer();
 buf.append("[");

        Iterator i = iterator();
        boolean hasNext = i.hasNext();
        while (hasNext) {
            Object o = i.next();
            buf.append(o == this ? "(this Collection)" : String.valueOf(o));
            hasNext = i.hasNext();
            if (hasNext)
                buf.append(", ");
        }

     buf.append("]");
     return buf.toString();
    }
最后一个方法了 , 就是把所有的元素用 [] 括起来返回 , 元素间用 ", " 分隔 . 这里唯一注意的是集合可以包含自己 , 如果没有判断就成死循环了 .