java.util.Collection
collection hierarchy的最顶层接口，collection是一组object的集合，jdk不提供任何直接实现Collection的类，但是对Collection的子接口（比如set、list）提供了实现类。这个接口的典型用法是遍历集合、大部分集合操作(包括包含关系判断、集合的并、差操作；集合的交操作不是基本操作，没有在Collection中定义)。
/** * The root interface in the <i>collection hierarchy</i>. A collection * represents a group of objects, known as its <i>elements</i>. Some * collections allow duplicate elements and others do not. Some are ordered * and others unordered. The JDK does not provide any <i>direct</i> * implementations of this interface: it provides implementations of more * specific subinterfaces like <tt>Set</tt> and <tt>List</tt>. This interface * is typically used to pass collections around and manipulate them where * maximum generality is desired. * @param <E> the type of elements in this collection * * @author Josh Bloch * @author Neal Gafter * @see Set * @see List * @see Map * @see SortedSet * @see SortedMap * @see HashSet * @see TreeSet * @see ArrayList * @see LinkedList * @see Vector * @see Collections * @see Arrays * @see AbstractCollection * @since 1.2 */ public interface Collection<E> extends Iterable<E> {
Collection定义的几个方法
Object[] toArray();这个方法是数组和collection之间的桥梁。
返回一个包含了集合内全部元素的数组。如果iterator方法返回的元素有序，那么此方法必须返回相同的顺序。
函数返回的数组是新开辟的，collection不包含返回数组的任何引用，这意味着可以任意修改返回数组而不影响collection
/** * Returns an array containing all of the elements in this collection. * If this collection makes any guarantees as to what order its elements * are returned by its iterator, this method must return the elements in * the same order. * * <p>The returned array will be "safe" in that no references to it are * maintained by this collection. (In other words, this method must * allocate a new array even if this collection is backed by an array). * The caller is thus free to modify the returned array. * * <p>This method acts as bridge between array-based and collection-based * APIs. * * @return an array containing all of the elements in this collection */ Object[] toArray();
<T> T[] toArray(T[] a);类似于Object[] toArray();但是有区别。
返回指定类型的数组，包含collection的全部元素，如果collection正好可以放进参数数组里，那么返回这个参数数组的引用。否则，返回一个新开辟的数组，大小和collection相同。
如果参数数组长度比collection大，那么后面的位置都赋值为null。
如果iterator方法返回有序，那么此方法返回同样顺序。
第四段是重点。此方法也是array和collection之间的桥梁。 <T> T[] toArray(T[] a)比Object[] toArray()更深一层的作用是：可以再运行时动态指定返回数组的类型，在某些情况下，这可以减少开辟数组的花销。哪些情况下呢？
/** * Returns an array containing all of the elements in this collection; * the runtime type of the returned array is that of the specified array. * If the collection fits in the specified array, it is returned therein. * Otherwise, a new array is allocated with the runtime type of the * specified array and the size of this collection. * * <p>If this collection fits in the specified array with room to spare * (i.e., the array has more elements than this collection), the element * in the array immediately following the end of the collection is set to * <tt>null</tt>. (This is useful in determining the length of this * collection <i>only</i> if the caller knows that this collection does * not contain any <tt>null</tt> elements.) * * <p>If this collection makes any guarantees as to what order its elements * are returned by its iterator, this method must return the elements in * the same order. * * <p>Like the {@link #toArray()} method, this method acts as bridge between * array-based and collection-based APIs. Further, this method allows * precise control over the runtime type of the output array, and may, * under certain circumstances, be used to save allocation costs. * * <p>Suppose <tt>x</tt> is a collection known to contain only strings. * The following code can be used to dump the collection into a newly * allocated array of <tt>String</tt>: * * <pre> * String[] y = x.toArray(new String[0]);</pre> * * Note that <tt>toArray(new Object[0])</tt> is identical in function to * <tt>toArray()</tt>. * * @param a the array into which the elements of this collection are to be * stored, if it is big enough; otherwise, a new array of the same * runtime type is allocated for this purpose. * @return an array containing all of the elements in this collection * @throws ArrayStoreException if the runtime type of the specified array * is not a supertype of the runtime type of every element in * this collection * @throws NullPointerException if the specified array is null */ <T> T[] toArray(T[] a);
判断集合包含关系的函数boolean containsAll(Collection<?> c);
注意：返回true不一定说明this和c包含相同的元素，只能说明this包含c。
集合的并操作 boolean addAll(Collection<? extends E> c);
此操作不包括以下情况：addAll的过程中参数被修改了；（一个例子就是，把非空集合本身做参数，因为addAll的过程中this一定会被修改）
/** * Adds all of the elements in the specified collection to this collection * (optional operation). The behavior of this operation is undefined if * the specified collection is modified while the operation is in progress. * (This implies that the behavior of this call is undefined if the * specified collection is this collection, and this collection is * nonempty.) boolean addAll(Collection<? extends E> c);
集合的差操作boolean removeAll(Collection<?> c);
Collection定义了一个Object的同名方法boolean equals(Object o);Collection接口本身不对equals作任何规定，但其子接口可能有特定的想法。
/** * Compares the specified object with this collection for equality. <p> * * While the <tt>Collection</tt> interface adds no stipulations to the * general contract for the <tt>Object.equals</tt>, programmers who * implement the <tt>Collection</tt> interface "directly" (in other words, * create a class that is a <tt>Collection</tt> but is not a <tt>Set</tt> * or a <tt>List</tt>) must exercise care if they choose to override the * <tt>Object.equals</tt>. It is not necessary to do so, and the simplest * course of action is to rely on <tt>Object</tt>'s implementation, but * the implementor may wish to implement a "value comparison" in place of * the default "reference comparison." (The <tt>List</tt> and * <tt>Set</tt> interfaces mandate such value comparisons.)<p> * * The general contract for the <tt>Object.equals</tt> method states that * equals must be symmetric (in other words, <tt>a.equals(b)</tt> if and * only if <tt>b.equals(a)</tt>). The contracts for <tt>List.equals</tt> * and <tt>Set.equals</tt> state that lists are only equal to other lists, * and sets to other sets. Thus, a custom <tt>equals</tt> method for a * collection class that implements neither the <tt>List</tt> nor * <tt>Set</tt> interface must return <tt>false</tt> when this collection * is compared to any list or set. (By the same logic, it is not possible * to write a class that correctly implements both the <tt>Set</tt> and * <tt>List</tt> interfaces.) * * @param o object to be compared for equality with this collection * @return <tt>true</tt> if the specified object is equal to this * collection * * @see Object#equals(Object) * @see Set#equals(Object) * @see List#equals(Object) */ boolean equals(Object o);
哈希函数同理，子接口的实现可能有特定的需求
int hashCode();