This implementation iterates over the specified collection, and adds each object returned by the iterator to this collection, in turn.

Note that this implementation will throw an UnsupportedOperationException unless add is overridden (assuming the specified collection is non-empty).
Throws:
- UnsupportedOperationException - {@inheritDoc}
- ClassCastException - {@inheritDoc}
- NullPointerException - {@inheritDoc}
- IllegalArgumentException - {@inheritDoc}
- IllegalStateException - {@inheritDoc}
See Also: AbstractCollection.add(Object),

This implementation iterates over the specified collection, checking each element returned by the iterator in turn to see if it's contained in this collection. If all elements are so contained true is returned, otherwise false.
Throws:
- ClassCastException - {@inheritDoc}
- NullPointerException - {@inheritDoc}
See Also: AbstractCollection.contains(Object),

This implementation first checks if the specified object is this set; if so it returns true. Then, it checks if the specified object is a set whose size is identical to the size of this set; if not, it returns false. If so, it returns containsAll((Collection) o).
Returns: true if the specified object is equal to this set
Parameters:
- o - object to be compared for equality with this set

This implementation iterates over the set, calling the hashCode method on each element in the set, and adding up the results.
Returns: the hash code value for this set
See Also: Object.equals(Object), Set.equals(Object),

This implementation determines which is the smaller of this set and the specified collection, by invoking the size method on each. If this set has fewer elements, then the implementation iterates over this set, checking each element returned by the iterator in turn to see if it is contained in the specified collection. If it is so contained, it is removed from this set with the iterator's remove method. If the specified collection has fewer elements, then the implementation iterates over the specified collection, removing from this set each element returned by the iterator, using this set's remove method.

Note that this implementation will throw an UnsupportedOperationException if the iterator returned by the iterator method does not implement the remove method.
Returns: true if this set changed as a result of the call
Parameters:
- c - collection containing elements to be removed from this set
Throws:
- UnsupportedOperationException - if the removeAll operation is not supported by this set
- ClassCastException - if the class of an element of this set is incompatible with the specified collection (optional)
- NullPointerException - if this set contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null
See Also: AbstractCollection.remove(Object), AbstractCollection.contains(Object),

This implementation iterates over this collection, checking each element returned by the iterator in turn to see if it's contained in the specified collection. If it's not so contained, it's removed from this collection with the iterator's remove method.

Note that this implementation will throw an UnsupportedOperationException if the iterator returned by the iterator method does not implement the remove method and this collection contains one or more elements not present in the specified collection.
Throws:
- UnsupportedOperationException - {@inheritDoc}
- ClassCastException - {@inheritDoc}
- NullPointerException - {@inheritDoc}
See Also: AbstractCollection.remove(Object), AbstractCollection.contains(Object),

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.

This method acts as bridge between array-based and collection-based APIs.

This implementation returns an array containing all the elements returned by this collection's iterator, in the same order, stored in consecutive elements of the array, starting with index 0. The length of the returned array is equal to the number of elements returned by the iterator, even if the size of this collection changes during iteration, as might happen if the collection permits concurrent modification during iteration. The size method is called only as an optimization hint; the correct result is returned even if the iterator returns a different number of elements.

This method is equivalent to:

 List<E> list = new ArrayList<E>(size());
 for (E e : this)
     list.add(e);
 return list.toArray();
 

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 null. (This is useful in determining the length of this collection only if the caller knows that this collection does not contain any null elements.)

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.

Like the Collection.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.

Suppose x is a collection known to contain only strings. The following code can be used to dump the collection into a newly allocated array of String:

     String[] y = x.toArray(new String[0]);

This implementation returns an array containing all the elements returned by this collection's iterator in the same order, stored in consecutive elements of the array, starting with index 0. If the number of elements returned by the iterator is too large to fit into the specified array, then the elements are returned in a newly allocated array with length equal to the number of elements returned by the iterator, even if the size of this collection changes during iteration, as might happen if the collection permits concurrent modification during iteration. The size method is called only as an optimization hint; the correct result is returned even if the iterator returns a different number of elements.

This method is equivalent to:

 List<E> list = new ArrayList<E>(size());
 for (E e : this)
     list.add(e);
 return list.toArray(a);