The HashSet class implements the Set interface, backed by a hash table which is actually a HashMap instance. No guarantee is made as to the iteration order of the set which means that the class does not guarantee the constant order of elements over time. This class permits the null element. The class also offers constant time performance for the basic operations like add, remove, contains, and size assuming the hash function disperses the elements properly among the buckets.
Few important features of HashSet are:
- Implements Set Interface.
- As it implements the Set Interface, duplicate values are not allowed.
- Objects that you insert in HashSet are not guaranteed to be inserted in the same order. Objects are inserted based on their hash code.
- NULL elements are allowed in HashSet.
- HashSet also implements Serializable and Cloneable interfaces.
Implementation:
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<T> { private Set<T> hashSet; // creating a set containing the elements in the // specified collection public HashSetImpl(Collection<? extends T> c) { hashSet = new HashSet<T>(c); } // constructing a set with given initialcapacity and // loadfactor public HashSetImpl(int initialCapacity,float loadFactor) { hashSet = new HashSet<T>(initialCapacity, loadFactor); } // specified initial capacity and default load factor // (0.75). public HashSetImpl(int initialCapacity) { hashSet = new HashSet<T>(initialCapacity); } // creating a new hashset with default capacity // 16 and load factor 0.75 public HashSetImpl() { hashSet = new HashSet<T>(); } // returns an iterator over the elements in the set public Iterator<T> 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<? extends T> 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> T[] toArray(T[] a) throws ArrayStoreException, NullPointerException { return hashSet.toArray(a); }} class Solution { public static void main(String arg[]) { HashSet<String> hashSet = new HashSet<String>(); 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<String> iterator = hashSet.iterator(); while (iterator.hasNext()) { System.out.print(iterator.next() + "\t"); } System.out.println(); Set<String> removedSet = new HashSet<String>(); removedSet.add("Nikhil"); removedSet.add("Kapil"); System.out.println("the elements after removing"); hashSet.removeAll(removedSet); Iterator<String> 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 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
