java的collections荟萃

下面这张表格（表一）总结了用一个荟萃能做的所有工作（亦可对Set和List做同样的工作，尽量List还提供了一些特另外成果）。Map不是从Collection担任的，所以要单独看待。

boolean add(Object) ＊担保荟萃内包括了自变量。假如它没有添加自变量，就返回false（假）
boolean addAll(Collection) ＊添加自变量内的所有元素。假如没有添加元素，则返回true（真）
void clear() ＊删除荟萃内的所有元素
boolean contains(Object) 若荟萃包括自变量，就返回“真”
boolean containsAll(Collection) 若荟萃包括了自变量内的所有元素，就返回“真”
boolean isEmpty() 若荟萃内没有元素，就返回“真”
Iterator iterator() 返回一个重复器，以用它遍历荟萃的各元素
boolean remove(Object) ＊如自变量在荟萃里，就删除谁人元素的一个实例。假如已举办了删除，就返回“真”
boolean removeAll(Collection) ＊删除自变量里的所有元素。假如已举办了任何删除，就返回“真”
boolean retainAll(Collection) ＊只保存包括在一个自变量里的元素（一个理论的“交集”）。假如已举办了任何改变，就返回“真”
int size() 返回荟萃内的元素数量
Object[] toArray() 返回包括了荟萃内所有元素的一个数组

Boolean add(Object)	*Ensures that the Collection contains the argument. Returns false if it doesn’t add the argument.
Boolean addAll(Collection)	*Adds all the elements in the argument. Returns true if any elements were added.
void clear()	*Removes all the elements in the Collection.
Boolean contains(Object)	True if the Collection contains the argument.
Boolean containsAll(Collection)	True if the Collection contains all the elements in the argument.
Boolean isEmpty()	True if the Collection has no elements.
Iterator iterator()	Returns an Iterator that you can use to move through the elements in the Collection.
Boolean remove(Object)	*If the argument is in the Collection, one instance of that element is removed. Returns true if a removal occurred.
Boolean removeAll(Collection)	*Removes all the elements that are contained in the argument. Returns true if any removals occurred.
Boolean retainAll(Collection)	*Retains only elements that are contained in the argument (an “intersection” from set theory). Returns true if any changes occurred.
int size()	Returns the number of elements in the Collection.
Object[] toArray()	Returns an array containing all the elements in the Collection.
Object[] toArray(Object[] a)	#p#分页标题#e# Returns an array containing all the elements in the Collection, whose type is that of the array a rather than plain Object (you must cast the array to the right type).
	*This is an “optional” method, which means it might not be implemented by a particular Collection. If not, that method throws an UnsupportedOperationException. Exceptions will be covered in Chapter 9.

表一

＊这是一个“可选的”要领，有的荟萃大概并未实现它。若确实如此，该要领就会碰着一个UnsupportedOperatiionException，即一个“操纵不支持”违例，详见第9章。

下面这个例子向各人演示了所有要领。同样地，它们只对从荟萃担任的对象有效，一个ArrayList作为一种“不常用的分母”利用：
 

//: Collection1.java
// Things you can do with all Collections
package c08.newcollections;
import java.util.*;

public class Collection1 {
  // Fill with 'size' elements, start
  // counting at 'start':
  public static Collection 
  fill(Collection c, int start, int size) {
    for(int i = start; i < start + size; i++)
      c.add(Integer.toString(i));
    return c;
  }
  // Default to a "start" of 0:
  public static Collection 
  fill(Collection c, int size) {
    return fill(c, 0, size);
  }
  // Default to 10 elements:
  public static Collection fill(Collection c) {
    return fill(c, 0, 10);
  }
  // Create & upcast to Collection:
  public static Collection newCollection() {
    return fill(new ArrayList());
    // ArrayList is used for simplicity, but it's
    // only seen as a generic Collection 
    // everywhere else in the program.
  }
  // Fill a Collection with a range of values:
  public static Collection 
  newCollection(int start, int size) {
    return fill(new ArrayList(), start, size);
  }
  // Moving through a List with an iterator:
  public static void print(Collection c) {
    for(Iterator x = c.iterator(); x.hasNext();)
      System.out.print(x.next() + " ");
    System.out.println();
  }    
  public static void main(String[] args) {
    Collection c = newCollection();
    c.add("ten");
    c.add("eleven");
    print(c);
    // Make an array from the List:
    Object[] array = c.toArray(); 
    // Make a String array from the List:
    String[] str = 
      (String[])c.toArray(new String[1]);
    // Find max and min elements; this means
    // different things depending on the way
    // the Comparable interface is implemented:
    System.out.println("Collections.max(c) = " +
      Collections.max(c));
    System.out.println("Collections.min(c) = " +
      Collections.min(c));
    // Add a Collection to another Collection
    c.addAll(newCollection());
    print(c);
    c.remove("3"); // Removes the first one
    print(c);
    c.remove("3"); // Removes the second one
    print(c);
    // Remove all components that are in the
    // argument collection:
    c.removeAll(newCollection());
    print(c);
    c.addAll(newCollection());
    print(c);
    // Is an element in this Collection
    System.out.println(
      "c.contains(\"4\") = " + c.contains("4"));
    // Is a Collection in this Collection
    System.out.println(
      "c.containsAll(newCollection()) = " + 
      c.containsAll(newCollection()));
    Collection c2 = newCollection(5, 3);
    // Keep all the elements that are in both
    // c and c2 (an intersection of sets):
    c.retainAll(c2);
    print(c);
    // Throw away all the elements in c that
    // also appear in c2:
    c.removeAll(c2);
    System.out.println("c.isEmpty() = " +
      c.isEmpty());
    c = newCollection();
    print(c);
    c.clear(); // Remove all elements
    System.out.println("after c.clear():");
    print(c);
  }
} ///:~

通过第一个要领，我们可用测试数据填充任何荟萃。在当前这种环境下，只是将int转换成String。第二个要领将在本章其余的部门常常回收。
newCollection()的两个版本都建设了ArrayList，用于包括差异的数据集，并将它们作为荟萃工具返回。所以很明明，除了Collection接口之外，不会再用到其他什么。
print()要领也会在本节常常用到。由于它用一个重复器（Iterator）在一个荟萃内遍历，而任何荟萃都可以发生这样的一个重复器，所以它合用于List和Set，也合用于由一个Map生成的Collection。
main()用简朴的手段显示出了荟萃内的所有要领。
在后续的小节里，我们将较量List，Set和Map的差异实现方案，同时指出在各类环境下哪一种方案应成为首选（带有星号的谁人）。各人会发明这里并未包罗一些传统的类，如Vector，Stack以及Hashtable等。因为不管在什么环境下，新荟萃内都有本身首选的类。