Java Program to Implement HashSet API

Code:

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetImpl
{
    private Set hashSet;

    /*
     * Constructs a new, empty set; the backing HashMap instance has default
     * initial capacity (16) and load factor (0.75).
     */
    public HashSetImpl()
    {
        hashSet = new HashSet();
    }

    /* Constructs a new set containing the elements in the specified collection. */
    public HashSetImpl(Collection c)
    {
        hashSet = new HashSet(c);
    }

    /*
     * constructs a new, empty set; the backing HashMap instance has the
     * specified initial capacity and the specified load factor.
     */
    public HashSetImpl(int initialCapacity, float loadFactor)
    {
        hashSet = new HashSet(initialCapacity, loadFactor);
    }

    /*
     * Constructs a new, empty set; the backing HashMap instance has the
     * specified initial capacity and default load factor (0.75).
     */
    public HashSetImpl(int initialCapacity)
    {
        hashSet = new HashSet(initialCapacity);
    }

    /* adds the specified element if not already present */
    public boolean add(E eobj)
    {
        return hashSet.add(eobj);
    }

    /* return true if this set contains the specified element */
    public boolean contains(Object obj)
    {
        return hashSet.contains(obj);
    }

    /* returns true if the set is empty */
    public boolean isEmpty()
    {
        return hashSet.isEmpty();
    }

    /* returns an iterator over the elements in the set */
    public Iterator iterator()
    {
        return hashSet.iterator();
    }

    /* removes the specified element from this set if present */
    public boolean remove(Object obj)
    {
        return hashSet.remove(obj);
    }

    /* returns the number of elements in set */
    public int size()
    {
        return hashSet.size();
    }

    /* removes all elements from this set */
    public void clear()
    {
        hashSet.clear();
    }

    /* Returns an array containing all of the elements in this set. */
    public Object[] toArray()
    {
        return hashSet.toArray();
    }

    /*
     * Adds all of the elements in the specified collection to this set if
     * they're not already present
     */
    public boolean addAll(Collection c)  
      throws UnsupportedOperationException, ClassCastException,NullPointerException,IllegalArgumentException      
    {
        return hashSet.addAll(c);
    }

    /*
     * Retains only the elements in this set that are contained in the specified
     * collection
     */
    public boolean retainAll(Collection c)
      throws UnsupportedOperationException, ClassCastException,NullPointerException
    {
        return hashSet.retainAll(c);
    }

    /*
     * Removes from this set all of its elements that are contained in the
     * specified collection
     */
    public boolean removeAll(Collection c)
      throws UnsupportedOperationException, NullPointerException,ClassCastException
    {
        return hashSet.retainAll(c);
    }

    /*
     * Returns an array containing all of the elements in this set; the runtime
     * type of the returned array is that of the specified array
     */
    public T[] toArray(T[] a)
      throws ArrayStoreException,NullPointerException
    {
        return hashSet.toArray(a);
    }

    public static void main(String... arg)
    {
        HashSet hashSet = new HashSet();
        if (hashSet.add(10))
            System.out.println("element 10 added");
        if (hashSet.add(20))
            System.out.println("element 20 added");
        if (hashSet.add(30))
            System.out.println("element 30 added");

        System.out.println("the size of set is " + hashSet.size());

        if (hashSet.contains(40))
            System.out.println("set contains 40");
        else
            System.out.println("set does not contain 40");

        if (hashSet.remove(20))
            System.out.println("element 20 removed");
        else
            System.out.println("element 20 not removed");

        System.out.println("the element of set are");
        Iterator iterator = hashSet.iterator();
        while (iterator.hasNext())
        {
            System.out.print(iterator.next() + "\t");
        }
        System.out.println();

        Set removedSet = new HashSet();
        removedSet.add(10);
        removedSet.add(20);

        System.out.println("the elements after removing");
        hashSet.removeAll(removedSet);
        Iterator riterator = hashSet.iterator();
        while(riterator.hasNext())
        {
            System.out.print(riterator.next() + "\t");
        }
        System.out.println();

        hashSet.clear();
        System.out.println("hashSet cleared");
        if (hashSet.isEmpty())
            System.out.println("hashSet is empty");
        else
            System.out.println("hashSet is not empty");
    }
}


Output:

element 10 added
element 20 added
element 30 added
the size of set is 3
set does not contain 40
element 20 removed
the element of set are
10 30
the elements after removing
30
hashSet cleared
hashSet is empty



More Java Programs: