HashSet in java

In this post we are going to learn hashset in java.

• underlying data structure for hashset is HashTable.
• Hashset do not allow duplicate elements. If any duplicate object is added, then add() method returns false without adding any duplicate object.
• Hashset insertion order is not preserved.
• In hashset all objects will be inserted based on hashcode.
• In hashset heterogeneous elements are allowed.
• Hashset allow null value.
• Hashset implements Serializable and Cloneable interface.
• In hashset searching objects is easier. Because objects are stored based on hashcode.

Also read – ArrayList java

Initial capacity : is initial number of buckets that a Hashset object can hold.

Load factor : is a measure to calculate till what load HashSet can allow elements to insert before size is increased.

 no. of elements in the table
load factor   =    ————————————————-
 size of hash table

NOTE : best load factor would be 0.75 with respect to time and space complexity, according to java.

Here you can see hierarchy of hashset class. Hashset class extends abstractset class. AbstractSet class implements set interface.

And set interface extends collection interface. Collection interface extends iterable interface.

java.util

Class HashSet<E>
java.lang.Object
     java.util.AbstractCollection<E>
          java.util.AbstractSet<E>
               java.util.HashSet<E>

Parameters
E - type of elements maintained by this set.

Implemented Interfaces
Serializable, Cloneable, Iterable<E>, Collection<E>, Set<E>

Subclasses
JobStateReasons, LinkedHashSet

Hashset class belongs to java.util package. Here letter “E” is type of elements added to hashset.

Type can be string, integer or object or user object etc. and hashset which extends abstractset.

Also read – sort Hashmap by value

Declaration – hashset class

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable

Hashset methods

Constructors in hashset

• HashSet h = new HashSet();

This constructor creates an empty hashset object with default initial capacity 16 and default fill ratio or load factor 0.75

• HashSet h = new HashSet(int initialCapacity);

this constructor creates hashset object with specified initialCapacity with load factor 0.75. Nothing but customized initial capacity with default load factor.

• HashSet h = new HashSet(int initialCapacity, float loadFactor);

Here we can customize load factor.

• HashSet h = new HashSet(Collection C);

If you want Interconversion between Collection object then use this constructor.

Let’s see java program on hashset,

import java.util.HashSet;
import java.util.Iterator;

public class HashsetExample
{
   public static void main(String[] args)
   {
      // HashSet declaration
      HashSet<String> hs = new HashSet<String>();
      // adding elements
      hs.add("orange");
      hs.add("mango");
      hs.add("strawberry");
      // now adding duplicate values to HashSet
      hs.add("orange");

      // display the HashSet 
      System.out.println(hs); 
      System.out.println("HashSet contains orange or not : " + hs.contains("orange")); 

      // removing item from HashSet using remove() method 
      hs.remove("mango"); 
      System.out.println("HashSet after removing - mango : " + hs); 

      // iterate over hashset 
      System.out.println("Iterating over list : "); 
      Iterator<String> iterate = hs.iterator(); 
      while(iterate.hasNext())
      {
         System.out.println(iterate.next());
      }
   }
}

Output:

[orange, strawberry, mango]
HashSet contains orange or not : true
HashSet after removing – mango : [orange, strawberry]
Iterating over list :
orange
strawberry

Reference – Oracle help centre