Go语言视频零基础入门到精通

javalearner

    AbstractCollection抽象类提供了Collection的骨架实现这里直接看它的代码是如何实现的.
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 = 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< SIZE; i++)
             a = 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();
     }
最后一个方法了,就是把所有的元素用[]括起来返回,元素间用", "分隔.这里唯一注意的是集合可以包含自己.

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=101622