Implements a HashSet where the objects given are stored in weak references : HashSet « Collections Data Structure « Java






Implements a HashSet where the objects given are stored in weak references

      
/*
 *     file: WeakHashSet.java
 *  package: oreilly.hcj.references
 *
 * This software is granted under the terms of the Common Public License,
 * CPL, which may be found at the following URL:
 * http://www-124.ibm.com/developerworks/oss/CPLv1.0.htm
 *
 * Copyright(c) 2003-2005 by the authors indicated in the @author tags.
 * All Rights are Reserved by the various authors.
 *
########## DO NOT EDIT ABOVE THIS LINE ########## */


import java.util.AbstractSet;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import java.util.WeakHashMap;

/**  
 * Implements a HashSet where the objects given are stored in weak references.
 * 
 * <p>
 * Uses the WeakHashMap class as a backing store to implement a set of objects that are
 * stored as weak references. All information concerning using keys in the WeakHashMap
 * class pertain to this class and it is reccomended that the user of this class review
 * that material before using the class.
 * </p>
 * 
 * <p>
 * Because this set contains only weak references, it is not serializable. If one tried
 * to serialize a weak reference, the results would be highly unpredictable as the
 * object could likely vanish from memory before the proces was even completed. Users of
 * this class must use transient when the containing class uses this set.
 * </p>
 * 
 * <p>
 * Because of the semantics of the weak references, the value null is not allowed in this
 * set.
 * </p>
 * 
 * <p>
 * This collection is not identity based but equality based. This can cause some
 * confusion as you cannot put in two objects whose <tt>equals()</tt> methods return
 * true. It also means that an object being held is not necessarily the same one that
 * the user is holding. For example, you could have a String with the value 'fred' at
 * memory location X and ther could be another String with the value 'fred' at memory
 * location Y. The first instance is in the set but the second isn't.
 * </p>
 *
 * @author <a href="mailto:worderisor@yahoo.com">Robert Simmons jr.</a>
 * @version $Revision: 1.8 $
 *
 * @see java.lang.util.WeakHashMap
 * @see java.lang.ref.WeakReference
 */
public class WeakHashSet extends AbstractSet implements Set {
  /** Dummy value used as a value object. */
  private static final Object DUMMY = new String("DUMMY");  //$NON-NLS-1$

  /** Holds the backing store. */
  WeakHashMap backingStore = new WeakHashMap();

  /** 
   * Constructs a new empty WeakHashSet with default values passed the the backing
   * store.
   *
   * @see java.util.WeakHashMap#WeakHashMap()
   */
  public WeakHashSet() {
    backingStore = new WeakHashMap();
  }

  /** 
   * Constructs a new WeakHashSet with default values passed the the backing store and
   * fills it with the given collection. Note that duplicates in the collection will
   * merely be overwritten
   *
   * @see java.util.WeakHashMap#WeakHashMap(Collection)
   */
  public WeakHashSet(final Collection c) {
    backingStore = new WeakHashMap(Math.max((int)(c.size() / .75f) + 1, 16));
    addAll(c);
  }

  /** 
   * Constructs a new WeakHashSet with the values given passed the the backing store.
   *
   * @see java.util.WeakHashMap#WeakHashMap(int, float)
   */
  public WeakHashSet(final int initialCapacity, final float loadFactor) {
    backingStore = new WeakHashMap(initialCapacity, loadFactor);
  }

  /** 
   * Constructs a new WeakHashSet with the values given passed the the backing store.
   *
   * @see java.util.WeakHashMap#WeakHashMap(int)
   */
  public WeakHashSet(final int initialCapacity) {
    backingStore = new WeakHashMap(initialCapacity);
  }

  /** 
   * {@inheritDoc}
   */
  public boolean isEmpty() {
    return backingStore.keySet()
                       .isEmpty();
  }

  /** 
   * {@inheritDoc}
   *
   * @throws NullPointerException If the user tries to add null to the set.
   */
  public boolean add(final Object o) {
    if (o == null) {
      throw new NullPointerException();
    }

    return backingStore.put(o, DUMMY) == null;
  }

  /** 
   * {@inheritDoc}
   *
   * @see #add(Object)
   */
  public boolean addAll(final Collection c) {
    boolean changed = false;
    Iterator iter = c.iterator();

    while (iter.hasNext()) {
      changed = (changed | (backingStore.put(iter.next(), DUMMY) != DUMMY));
    }

    return changed;
  }

  /** 
   * {@inheritDoc}
   */
  public void clear() {
    backingStore.clear();
  }

  /** 
   * {@inheritDoc}
   */
  public boolean contains(final Object o) {
    return backingStore.containsKey(o);
  }

  /** 
   * {@inheritDoc}
   */
  public boolean containsAll(final Collection c) {
    return backingStore.keySet()
                       .containsAll(c);
  }

  /** 
   * {@inheritDoc}
   */
  public boolean equals(final Object o) {
    return backingStore.equals(o);
  }

  /** 
   * Returns the hash code value for this set.
   * 
   * <p>
   * Gives back the hashCode for the backing store key set. The user should be aware,
   * however, that this hash code can change without user intervention as the objects
   * in the collection can easily be collected microseconds after completetion of the
   * method. It is not reccomended that the user rely on this hash code for
   * consistency
   * </p>
   *
   * @return The hashcode for this object.
   */
  public int hashCode() {
    return backingStore.keySet()
                       .hashCode();
  }

  /** 
   * Returns an iterator over the elements contained in this collection.
   * 
   * <p>
   * Note that this iterator is extremely volatile because the user may iterate over an
   * element in the set and find seconds later that it has been removed. This is
   * because of the semantics of weak references which act like a second thread is
   * silently modifying the collection. For this reason, it is advisable that if the
   * user wants to do something with the set that they maintain a strong reference to
   * the object and not rely on it being in the collection for them.
   * </p>
   * 
   * <p>
   * This iterator is fail fast and WeakReference transparrent. By this we mean that
   * the iterator simply ignores objects pending in the reference queue for cleanup.
   * </p>
   *
   * @return The iterator.
   */
  public Iterator iterator() {
    return backingStore.keySet()
                       .iterator();
  }

  /** 
   * {@inheritDoc}
   */
  public boolean remove(final Object o) {
    return backingStore.keySet()
                       .remove(o);
  }

  /** 
   * {@inheritDoc}
   */
  public boolean removeAll(final Collection c) {
    return backingStore.keySet()
                       .removeAll(c);
  }

  /** 
   * {@inheritDoc}
   */
  public boolean retainAll(final Collection c) {
    return backingStore.keySet()
                       .retainAll(c);
  }

  /** 
   * {@inheritDoc}
   */
  public int size() {
    return backingStore.keySet()
                       .size();
  }

  /** 
   * {@inheritDoc}
   */
  public Object[] toArray() {
    return backingStore.keySet()
                       .toArray();
  }

  /** 
   * {@inheritDoc}
   */
  public Object[] toArray(final Object[] a) {
    return backingStore.keySet()
                       .toArray(a);
  }

  /** 
   * {@inheritDoc}
   */
  public String toString() {
    return backingStore.keySet()
                       .toString();
  }

  /** 
   * {@inheritDoc}
   */
  protected Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
  }
}

/* ########## End of File ########## */

   
    
    
    
    
    
  








Related examples in the same category

1.Add values to HashSet
2.HashSet implementation of setHashSet implementation of set
3.Generic collection conversion: HashSet and ArrayList
4.Remove one set from another set
5.Remove element from HashSet
6.Find maximum element of Java HashSet
7.Find Minimum element of Java HashSet
8.Get Enumeration over Java HashSet
9.Get Synchronized Set from Java HashSet
10.Check if a particular element exists in Java HashSet
11.Copy all elements of Java HashSet to an Object Array
12.Get Size of Java HashSet
13.Iterate through elements of Java HashSet
14.Integer value set
15.Listing the Elements of a Collection(iterate over the elements of set or list)
16.Remove specified element from Java HashSet
17.Remove all elements from Java HashSet
18.Convert array to Set
19.Convert an ArrayList to HashSet
20.Create an array containing the elements in a set
21.Duplicate elements are discarded
22.Convert Set into array
23.A memory-efficient hash set.
24.Compact HashSet
25.Coarse-grained hash set.
26.Concurrent hash set that allows the lock array to be resized.
27.A CompactHashSet implements the set interface more tightly in memory and more efficiently than Java's java.util.HashSet.
28.Concurrent HashSet