A thin wrapper around a List transforming it into a modifiable Set. : Set « Collections « Java Tutorial






import java.io.Serializable;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

/**
 * A thin wrapper around a <code>List</code> transforming it into a modifiable
 * <code>Set</code>.
 * 
 * @version <tt>$Revision: 2800 $</tt>
 * @author <a href="mailto:jason@planet57.com">Jason Dillon</a>
 */
@SuppressWarnings("unchecked")
public class ListSet extends AbstractSet implements Set, Cloneable, Serializable {
  /** The serialVersionUID */
  private static final long serialVersionUID = 7333619218072079496L;

  /** The <tt>List</tt> which will be used for element storage. */
  protected final List list;

  /**
   * Construct a <tt>ListSet</tt>.
   * 
   * @param list
   *          The <tt>List</tt> which will be used for element storage.
   * 
   * @throws IllegalArgumentException
   *           List is <tt>null</tt> or contains duplicate entries.
   */
  public ListSet(final List list) {
    if (list == null)
      throw new RuntimeException("list");

    // make sure there are no duplicates
    int size = list.size();
    for (int i = 0; i < size; i++) {
      Object obj = list.get(i);
      if (list.indexOf(obj) != list.lastIndexOf(obj)) {
        throw new IllegalArgumentException("list contains duplicate entries");
      }
    }

    this.list = list;
  }

  /**
   * Construct a <tt>ListSet</tt> using an <tt>ArrayList</tt> for backing.
   */
  public ListSet() {
    this(new ArrayList());
  }

  /**
   * Construct a <tt>ListSet</tt> using an <tt>ArrayList</tt> for backing
   * and populated with the given elements.
   * 
   * @param elements
   *          The elements for the list.
   */
  public ListSet(final Collection elements) {
    this(new ArrayList(elements));
  }

  public List getList() {
    return list;
  }

  /**
   * Return the size of the set.
   * 
   * @return The size of the set.
   */
  public int size() {
    return list.size();
  }

  /**
   * Return an iteration over the elements in the set.
   * 
   * @return An iteration over the elements in the set.
   */
  public Iterator iterator() {
    return list.iterator();
  }

  /**
   * Add an element to the set.
   * 
   * @param obj
   *          Element to add to the set.
   * @return True if the element was added.
   */
  public boolean add(final Object obj) {
    boolean added = false;

    if (!list.contains(obj)) {
      added = list.add(obj);
    }

    return added;
  }

  /**
   * Returns <tt>true</tt> if this set contains no elements.
   * 
   * @return <tt>true</tt> if this set contains no elements.
   */
  public boolean isEmpty() {
    return list.isEmpty();
  }

  /**
   * Returns <tt>true</tt> if this set contains the specified element.
   * 
   * @param obj
   *          Element whose presence in this set is to be tested.
   * @return <tt>true</tt> if this set contains the specified element.
   */
  public boolean contains(final Object obj) {
    return list.contains(obj);
  }

  /**
   * Removes the given element from this set if it is present.
   * 
   * @param obj
   *          Object to be removed from this set, if present.
   * @return <tt>true</tt> if the set contained the specified element.
   */
  public boolean remove(final Object obj) {
    return list.remove(obj);
  }

  /**
   * Removes all of the elements from this set.
   */
  public void clear() {
    list.clear();
  }

  /**
   * Returns a shallow copy of this <tt>ListSet</tt> instance.
   * 
   * @return A shallow copy of this set.
   */
  public Object clone() {
    try {
      return super.clone();
    } catch (CloneNotSupportedException e) {
      throw new InternalError();
    }
  }
}








9.18.Set
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