Implements a HashSet where the objects given are stored in weak references : 哈希集 « 集合数据结构 « Java

En
Java
1. 图形用户界面
2. 三维图形动画
3. 高级图形
4. 蚂蚁编译
5. Apache类库
6. 统计图
7. 
8. 集合数据结构
9. 数据类型
10. 数据库JDBC
11. 设计模式
12. 开发相关类
13. EJB3
14. 电子邮件
15. 事件
16. 文件输入输出
17. 游戏
18. 泛型
19. GWT
20. Hibernate
21. 本地化
22. J2EE平台
23. 基于J2ME
24. JDK-6
25. JNDI的LDAP
26. JPA
27. JSP技术
28. JSTL
29. 语言基础知识
30. 网络协议
31. PDF格式RTF格式
32. 映射
33. 常规表达式
34. 脚本
35. 安全
36. Servlets
37. Spring
38. Swing组件
39. 图形用户界面
40. SWT-JFace-Eclipse
41. 线程
42. 应用程序
43. Velocity
44. Web服务SOA
45. 可扩展标记语言
Java 教程
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() .75f116));
    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. 添加值HashSet
2. HashSet implementation of setHashSet implementation of set
3. Generic collection conversion: HashSet and ArrayList
4. Remove one set from another set
5. 移除元素HashSet
6. 找到最大元素Java HashSet
7. 寻找最小元素Java HashSet
8. Get Enumeration over Java HashSet
9. 得到同步设置Java HashSet
10. 检查是否存在某一特定因素在Java HashSet
11. 复制所有内容Java HashSet的对象数组
12. 获取大小Java HashSet
13. 遍历元素Java HashSet
14. 整型值设置
15. Listing the Elements of a Collection(iterate over the elements of set or list)
16. 从Java HashSet删除指定元素
17. 移除所有内容Java HashSet
18. 转换数组设置
19. Convert an ArrayList to HashSet
20. Create an array containing the elements in a set
21. 丢弃重复的内容
22. Convert Set into array
www.java2java.com | Contact Us
Copyright 2010 - 2030 Java Source and Support. All rights reserved.
All other trademarks are property of their respective owners.