A weak HashSet: element stored in the WeakHashSet might be garbage collected : Set « Collections « Java Tutorial

 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License.

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.HashSet;
import java.util.Iterator;

 * A weak HashSet. An element stored in the WeakHashSet might be
 * garbage collected, if there is no strong reference to this element.

public class WeakHashSet extends HashSet {
     * Helps to detect garbage collected values.
    ReferenceQueue queue = new ReferenceQueue();

     * Returns an iterator over the elements in this set.  The elements
     * are returned in no particular order.
     * @return an Iterator over the elements in this set.
    public Iterator iterator() {
        // remove garbage collected elements

        // get an iterator of the superclass WeakHashSet
        final Iterator i = super.iterator();

        return new Iterator() {
            public boolean hasNext() {
                return i.hasNext();

            public Object next() {
                // unwrap the element
                return getReferenceObject((WeakReference) i.next());

            public void remove() {
                // remove the element from the HashSet

     * Returns <code>true</code> if this set contains the specified element.
     * @param o element whose presence in this set is to be tested.
     * @return <code>true</code> if this set contains the specified element.
    public boolean contains(Object o) {
        return super.contains(WeakElement.create(o));

     * Adds the specified element to this set if it is not already
     * present.
     * @param o element to be added to this set.
     * @return <code>true</code> if the set did not already contain the specified
     * element.
    public boolean add(Object o) {
        return super.add(WeakElement.create(o, this.queue));

     * Removes the given element from this set if it is present.
     * @param o object to be removed from this set, if present.
     * @return <code>true</code> if the set contained the specified element.
    public boolean remove(Object o) {
        boolean ret = super.remove(WeakElement.create(o));
        return ret;

     * A convenience method to return the object held by the
     * weak reference or <code>null</code> if it does not exist.
    private final Object getReferenceObject(WeakReference ref) {
        return (ref == null) ? null : ref.get();

     * Removes all garbage collected values with their keys from the map.
     * Since we don't know how much the ReferenceQueue.poll() operation
     * costs, we should call it only in the add() method.
    private final void processQueue() {
        WeakElement wv = null;

        while ((wv = (WeakElement) this.queue.poll()) != null) {

     * A WeakHashSet stores objects of class WeakElement.
     * A WeakElement wraps the element that should be stored in the WeakHashSet.
     * WeakElement inherits from java.lang.ref.WeakReference.
     * It redefines equals and hashCode which delegate to the corresponding methods
     * of the wrapped element.
    static private class WeakElement extends WeakReference {
        private int hash; /* Hashcode of key, stored here since the key
                               may be tossed by the GC */

        private WeakElement(Object o) {
            hash = o.hashCode();

        private WeakElement(Object o, ReferenceQueue q) {
            super(o, q);
            hash = o.hashCode();

        private static WeakElement create(Object o) {
            return (o == null) ? null : new WeakElement(o);

        private static WeakElement create(Object o, ReferenceQueue q) {
            return (o == null) ? null : new WeakElement(o, q);

        /* A WeakElement is equal to another WeakElement iff they both refer to objects
               that are, in turn, equal according to their own equals methods */
        public boolean equals(Object o) {
            if (this == o)
                return true;
            if (!(o instanceof WeakElement))
                return false;
            Object t = this.get();
            Object u = ((WeakElement) o).get();
            if (t == u) 
                return true;
            if ((t == null) || (u == null))
                return false;
            return t.equals(u);

        public int hashCode() {
            return hash;


9.18.1.Convert a List to a Set
9.18.2.Convert an ArrayList to HashSet
9.18.3.Creating a Sorted Set
9.18.4.Create new sets from Iterable, var argv
9.18.5.Create an array containing the elements in a set
9.18.6.Comparable with a sorted collection.
9.18.7.Duplicate elements are discarded
9.18.8.Creating a Set That Retains Order-of-Insertion
9.18.9.Convert Set into array
9.18.10.Convert Set into List
9.18.11.Copy all the elements from set2 to set1 (set1 += set2), set1 becomes the union of set1 and set2
9.18.12.Remove all the elements in set1 from set2 (set1 -= set2), set1 becomes the asymmetric difference of set1 and set2
9.18.13.Get the intersection of set1 and set2, set1 becomes the intersection of set1 and set2
9.18.14.Set operations: union, intersection, difference, symmetric difference, is subset, is superset
9.18.15.Remove all elements from a set
9.18.16.List Set
9.18.17.Set implementation that use == instead of equals()
9.18.18.Set union and intersection
9.18.19.Set with values iterated in insertion order.
9.18.20.Implements the Set interface, backed by a ConcurrentHashMap instance
9.18.21.A weak HashSet: element stored in the WeakHashSet might be garbage collected
9.18.22.An IdentitySet that uses reference-equality instead of object-equality
9.18.23.A thin wrapper around a List transforming it into a modifiable Set.
9.18.24.Concurrent set
9.18.25.Set that compares object by identity rather than equality