实现HashSet API的Java程序

HashSet 类实现了 Set 接口，由一个哈希表支持，它实际上是一个 HashMap 实例。不保证集合的迭代顺序，这意味着该类不保证元素随时间的恒定顺序。此类允许空元素。该类还为基本操作（如添加、删除、包含和大小）提供恒定的时间性能，假设散列函数在存储桶中正确分散元素。

HashSet 的几个重要特性是：

• 实现 Set 接口。
• 由于它实现了 Set 接口，因此不允许出现重复值。
• 您在 HashSet 中插入的对象不能保证以相同的顺序插入。对象是根据它们的哈希码插入的。
• HashSet 中允许使用 NULL 元素。
• HashSet 还实现了 Serializable和Cloneable接口。

执行：

Java

// Java Program to Implement HashSet API
  
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
  
public class HashSetImpl {
    private Set hashSet;
  
    // creating a set containing the elements in the
    // specified collection
    public HashSetImpl(Collection c)
    {
        hashSet = new HashSet(c);
    }
  
    // constructing a set with given initialcapacity and
    // loadfactor
    public HashSetImpl(int initialCapacity,float loadFactor)
    {
        hashSet = new HashSet(initialCapacity, loadFactor);
    }
  
    // specified initial capacity and default load factor
    // (0.75).
  
    public HashSetImpl(int initialCapacity)
    {
        hashSet = new HashSet(initialCapacity);
    }
    
    // creating a new hashset with default capacity
    // 16 and load factor 0.75
    public HashSetImpl() { hashSet = new HashSet(); }
  
    // returns an iterator over the elements in the set
    public Iterator iterator()
    {
        return hashSet.iterator();
    }
  
    // adding the element into the hashset
    public boolean add(T 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(); }
  
    // 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 with 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);
    }
}
  
class Solution {
  
    public static void main(String arg[])
    {
        HashSet hashSet = new HashSet();
        
        if (hashSet.add("Mani"))
            System.out.println("element Mani added");
        
        if (hashSet.add("Rohit"))
            System.out.println("element Rohit added");
        
        if (hashSet.add("Manish"))
            System.out.println("element Manish added");
  
        System.out.println("the size of set is "
                           + hashSet.size());
  
        if (hashSet.contains("Sachin"))
            System.out.println("set contains Sachin");
        else
            System.out.println("set does not contain Sachin");
  
        if (hashSet.remove("Mani"))
            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("Nikhil");
        removedSet.add("Kapil");
  
        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");
    }
}

输出

element Mani added
element Rohit added
element Manish added
the size of set is 3
set does not contain Sachin
element 20 removed
the element of set are
Rohit    Manish    
the elements after removing
Rohit    Manish    
hashSet cleared
hashSet is empty