* * 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 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 l is a List known to contain only strings. The * following code can be used to dump the list into a newly allocated array * of String :
* String[] x = (String[]) v.toArray(new String[0]);
* * * Note that toArray(new Object[0]) is identical in function to * toArray() . * * @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 the elements of this collection * @throws ArrayStoreException the runtime type of the specified array is * not a supertype of the runtime type of every element in this * collection. */ public Object[] toArray(Object[] a) { processQueue(); return getEntrySet().toArray(a); } /*** * Removes all this collection's elements that are also contained in the * specified collection (optional operation). After this call returns, this * collection will contain no elements in common with the specified * collection. * * @param c elements to be removed from this collection. * @return true if this collection changed as a result of the call * @throws UnsupportedOperationException if the removeAll method is * not supported by this collection. * @see #remove(Object) * @see #contains(Object) */ public boolean removeAll(Collection c) { throw new UnsupportedOperationException(); } /*** * Returns an array containing all of the elements in this collection. If * the 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.
* * 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. * * @return an array containing all of the elements in this collection */ public Object[] toArray() { processQueue(); return getEntrySet().toArray(); } /*** * Returns an iterator over the elements in this collection. There are no * guarantees concerning the order in which the elements are returned * (unless this collection is an instance of some class that provides a * guarantee). * * @return an Iterator over the elements in this collection */ public Iterator iterator() { processQueue(); return new WeakIterator(); } /*** * Removes a single instance of the specified element from this collection, * if it is present (optional operation). More formally, removes an element * e such that (o==null ? e==null : o.equals(e)) , if this * collection contains one or more such elements. Returns true if this * collection contained the specified element (or equivalently, if this * collection changed as a result of the call). * * @param o element to be removed from this collection, if present. * @return true if this collection changed as a result of the call * @throws UnsupportedOperationException remove is not supported by this * collection. */ public boolean remove(Object o) { return contents.remove(WeakEntry.create(o)); } /*** * Removes all of the elements from this collection (optional operation). * This collection will be empty after this method returns unless it throws * an exception. * * @throws UnsupportedOperationException if the clear method is not * supported by this collection. */ public void clear() { contents.clear(); } /*** * Returns the hash code value for this collection. While the Collection * interface adds no stipulations to the general contract for the * Object.hashCode method, programmers should take note that any class * that overrides the Object.equals method must also override the * Object.hashCode method in order to satisfy the general contract * for the Object.hashCode method. In particular, c1.equals(c2) * implies that c1.hashCode()==c2.hashCode() . * * @return the hash code value for this collection * @see Object#hashCode() * @see Object#equals(Object) */ public int hashCode() { processQueue(); return contents.hashCode(); } /*** * 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.) * * @param c elements to be inserted into this collection. * @return true if this collection changed as a result of the call * @throws UnsupportedOperationException if this collection does not support * the addAll method. * @throws ClassCastException if the class of an element of the specified * collection prevents it from being added to this collection. * @throws IllegalArgumentException some aspect of an element of the * specified collection prevents it from being added to this * collection. * @see #add(Object) */ public boolean addAll(Collection c) { boolean changed = false; for (Iterator i = c.iterator(); i.hasNext(); ) { changed |= add(i.next()); } return changed; } /*** * Returns the number of elements in this collection. If this collection * contains more than Integer.MAX_VALUE elements, returns * Integer.MAX_VALUE . * * @return the number of elements in this collection */ public int size() { processQueue(); return contents.size(); } /*** * Returns true if this collection contains all of the elements in * the specified collection. * * @param c collection to be checked for containment in this collection. * @return true if this collection contains all of the elements in * the specified collection * @see #contains(Object) */ public boolean containsAll(Collection c) { processQueue(); return getEntrySet().containsAll(c); } /*** * Ensures that this collection contains the specified element (optional * operation). Returns true if this collection changed as a result * of the call. (Returns false if this collection does not permit * duplicates and already contains the specified element.)
* * Collections that support this operation may place limitations on what * elements may be added to this collection. In particular, some collections * will refuse to add null elements, and others will impose * restrictions on the type of elements that may be added. Collection * classes should clearly specify in their documentation any restrictions on * what elements may be added.
* * If a collection refuses to add a particular element for any reason other * than that it already contains the element, it must throw an * exception (rather than returning false ). This preserves the * invariant that a collection always contains the specified element after * this call returns. * * @param o element whose presence in this collection is to be ensured. * @return true if this collection changed as a result of the call * @throws UnsupportedOperationException add is not supported by this * collection. * @throws ClassCastException class of the specified element prevents it * from being added to this collection. * @throws IllegalArgumentException some aspect of this element prevents it * from being added to this collection. */ public boolean add(Object o) { return contents.add(WeakEntry.create(o, referenceQueue)); } /*** * Compares the specified object with this collection for equality.
* * While the Collection interface adds no stipulations to the * general contract for the Object.equals , programmers who * implement the Collection interface "directly" (in other words, * create a class that is a Collection but is not a Set or * a List ) must exercise care if they choose to override the * Object.equals . It is not necessary to do so, and the simplest * course of action is to rely on Object 's implementation, but the * implementer may wish to implement a "value comparison" in place of the * default "reference comparison." (The List and Set * interfaces mandate such value comparisons.)
* * The general contract for the Object.equals method states that * equals must be symmetric (in other words, a.equals(b) if and * only if b.equals(a) ). The contracts for List.equals * and Set.equals state that lists are only equal to other lists, * and sets to other sets. Thus, a custom equals method for a * collection class that implements neither the List nor Set * interface must return false 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 Set and * List interfaces.) * * @param o Object to be compared for equality with this collection. * @return true if the specified object is equal to this collection * @see Object#equals(Object) * @see java.util.Set#equals(Object) * @see java.util.List#equals(Object) */ public boolean equals(Object o) { processQueue(); return contents.equals(o); } /*** * Creates an unwrappered copy of the contents * * @return The entrySet value */ private final Set getEntrySet() { Set temp = new HashSet(); for (Iterator i = contents.iterator(); i.hasNext(); ) { temp.add(i.next()); } return temp; } /*** * Removes any entries that have been garbage collected. I saw a note in * WeakHashMap that warns against calling this any mutators so I have taken * the same approach here. */ private final void processQueue() { Reference reference = null; while ((reference = referenceQueue.poll()) != null) { contents.remove(reference); } } static class WeakEntry extends WeakReference { private final int hashCode; private WeakEntry(Object entry) { super(entry); hashCode = entry.hashCode(); } private WeakEntry(Object entry, ReferenceQueue referenceQueue) { super(entry, referenceQueue); hashCode = entry.hashCode(); } static WeakEntry create(Object entry) { if (entry != null) { return new WeakEntry(entry); } else { return null; } } static WeakEntry create(Object entry, ReferenceQueue referenceQueue) { if (entry != null) { return new WeakEntry(entry, referenceQueue); } else { return null; } } public int hashCode() { return hashCode; } public boolean equals(Object o) { if (this == o) { return true; } else if (!(o instanceof WeakEntry)) { return false; } Object t = this.get(); Object u = ((WeakEntry) o).get(); if ((t == null) || (u == null)) { return false; } else if (t == u) { return true; } else { return t.equals(u); } } } /*** * Smart iterator over the contents. Smart because it handles the effects of * garbage collection behind its back. * */ class WeakIterator implements Iterator { /*** * The "real" iterator over the contents */ private final Iterator iterator = contents.iterator(); /*** * Has the caller obtained the next object yet? */ private boolean gotNext = true; /*** * Is there a next object? */ private boolean hasNext = false; /*** * The next object (if any) */ private Object next = null; /*** * Returns true if the iteration has more elements. (In other * words, returns true if next would return an element * rather than throwing an exception.) * * @return true if the iterator has more elements. */ public boolean hasNext() { if (gotNext) { next = null; hasNext = false; while (iterator.hasNext()) { Reference reference = (Reference) iterator.next(); if (reference != null) { next = reference.get(); if (next != null) { hasNext = true; break; } } else { hasNext = true; break; } } } gotNext = false; return hasNext; } /*** * Returns the next element in the interation. * * @return the next element in the iteration. */ public Object next() { if (hasNext()) { Object o = next; next = null; gotNext = true; return o; } throw new NoSuchElementException(); } /*** * Removes from the underlying collection the last element returned by * the iterator (optional operation). This method can be called only * once per call to next . The behavior of an iterator is * unspecified if the underlying collection is modified while the * iteration is in progress in any way other than by calling this * method. */ public void remove() { next = null; gotNext = true; iterator.remove(); } } }