Java tutorial
/* * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.util; /** * This class provides a skeletal implementation of the {@code Set} * interface to minimize the effort required to implement this * interface. <p> * * 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 {@code Set} * interface (for instance, the add method must not permit addition of * multiple instances of an object to a set).<p> * * Note that this class does not override any of the implementations from * the {@code AbstractCollection} class. It merely adds implementations * for {@code equals} and {@code hashCode}.<p> * * This class is a member of the * <a href="{@docRoot}/java.base/java/util/package-summary.html#CollectionsFramework"> * Java Collections Framework</a>. * * @param <E> the type of elements maintained by this set * * @author Josh Bloch * @author Neal Gafter * @see Collection * @see AbstractCollection * @see Set * @since 1.2 */ public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> { /** * Sole constructor. (For invocation by subclass constructors, typically * implicit.) */ protected AbstractSet() { } // Comparison and hashing /** * Compares the specified object with this set for equality. Returns * {@code true} if the given object is also a set, the two sets have * the same size, and every member of the given set is contained in * this set. This ensures that the {@code equals} method works * properly across different implementations of the {@code Set} * interface.<p> * * This implementation first checks if the specified object is this * set; if so it returns {@code 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 * {@code containsAll((Collection) o)}. * * @param o object to be compared for equality with this set * @return {@code 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 | 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, * where the hash code of a {@code null} element is defined to be zero. * This ensures that {@code s1.equals(s2)} implies that * {@code s1.hashCode()==s2.hashCode()} for any two sets {@code s1} * and {@code s2}, as required by the general contract of * {@link Object#hashCode}. * * <p>This implementation iterates over the set, calling the * {@code hashCode} method on each element in the set, and adding up * the results. * * @return the hash code value for this set * @see Object#equals(Object) * @see Set#equals(Object) */ public int hashCode() { int h = 0; Iterator<E> i = iterator(); while (i.hasNext()) { E obj = i.next(); if (obj != null) h += obj.hashCode(); } return h; } /** * Removes from this set all of its elements that are contained in the * specified collection (optional operation). If the specified * collection is also a set, this operation effectively modifies this * set so that its value is the <i>asymmetric set difference</i> of * the two sets. * * <p>This implementation determines which is the smaller of this set * and the specified collection, by invoking the {@code 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 {@code 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 {@code remove} method. * * <p>Note that this implementation will throw an * {@code UnsupportedOperationException} if the iterator returned by the * {@code iterator} method does not implement the {@code remove} method. * * @param c collection containing elements to be removed from this set * @return {@code true} if this set changed as a result of the call * @throws UnsupportedOperationException if the {@code removeAll} operation * is not supported by this set * @throws ClassCastException if the class of an element of this set * is incompatible with the specified collection * (<a href="Collection.html#optional-restrictions">optional</a>) * @throws NullPointerException if this set contains a null element and the * specified collection does not permit null elements * (<a href="Collection.html#optional-restrictions">optional</a>), * or if the specified collection is null * @see #remove(Object) * @see #contains(Object) */ public boolean removeAll(Collection<?> c) { Objects.requireNonNull(c); boolean modified = false; if (size() > c.size()) { for (Object e : c) modified |= remove(e); } else { for (Iterator<?> i = iterator(); i.hasNext();) { if (c.contains(i.next())) { i.remove(); modified = true; } } } return modified; } }