/* * @(#)AbstractSet.java 1.26 04/02/19 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.util; /** * This class provides a skeletal implementation of the Set * interface to minimize the effort required to implement this * interface.
* * The process of implementing a set by extending this class is identical * to that of implementing a Collection by extending AbstractCollection, * except that all of the methods and constructors in subclasses of this * class must obey the additional constraints imposed by the Set * interface (for instance, the add method must not permit addition of * multiple instances of an object to a set).
* * Note that this class does not override any of the implementations from * the AbstractCollection class. It merely adds implementations * for equals and hashCode.
*
* This class is a member of the
*
* Java Collections Framework.
*
* @author Josh Bloch
* @author Neal Gafter
* @version 1.26, 02/19/04
* @see Collection
* @see AbstractCollection
* @see Set
* @since 1.2
*/
public abstract class AbstractSet
*
* 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).
*
* @param o Object to be compared for equality with this set.
* @return true if the specified object is equal to this set.
*/
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Set))
return false;
Collection c = (Collection) o;
if (c.size() != size())
return false;
try {
return containsAll(c);
} catch(ClassCastException unused) {
return false;
} catch(NullPointerException unused) {
return false;
}
}
/**
* Returns the hash code value for this set. The hash code of a set is
* defined to be the sum of the hash codes of the elements in the set.
* This ensures that s1.equals(s2) implies that
* s1.hashCode()==s2.hashCode() for any two sets s1
* and s2, as required by the general contract of
* Object.hashCode.
*
* This implementation enumerates over the set, calling the
* hashCode method on each element in the collection, and
* adding up the results.
*
* @return the hash code value for this set.
*/
public int hashCode() {
int h = 0;
Iterator
*
* 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.
*
* @param c elements to be removed from this set.
* @return true if this set changed as a result of the call.
*
* @throws UnsupportedOperationException removeAll is not supported
* by this set.
* @throws NullPointerException if the specified collection is null.
* @see #remove(Object)
* @see #contains(Object)
*/
public boolean removeAll(Collection> c) {
boolean modified = false;
if (size() > c.size()) {
for (Iterator> i = c.iterator(); i.hasNext(); )
modified |= remove(i.next());
} else {
for (Iterator> i = iterator(); i.hasNext(); ) {
if (c.contains(i.next())) {
i.remove();
modified = true;
}
}
}
return modified;
}
}