HashSet In Java

Introduction:

HashSet in Java implements Set interface i.e. it doesn’t allow duplicates. It is internally backed by a HashMap which works on the principle of hashing. 

We can store a null value in a HashSet. Its default capacity is 16 with a load factor of 0.75, where:

Load factor = Number of Stored Elements / capacity

A Java HashSet is non-synchronized. Also, there’s no guarantee to retain the insertion order of elements.

In this tutorial, we’ll learn how to work with a Java HashSet.

Instantiating HashSet:

We can create a Java HashSet using one of the following constructors:

HashSet() // default capacity of 16 with a load factor of 0.75
HashSet(int initialCapacity)
HashSet(int initialCapacity, float loadFactor)
HashSet(Collection c)

Each of these constructor usages is pretty intuitive.

Let’s quickly create a HashSet using the default constructor:

Set<Integer> set = new HashSet<>();

Commonly Used Methods:

Let’s now look at some methods that can help us manipulate over a Java HashSet:

1. boolean add(E e):

It simply adds an element to the given set, if not present already. If the element is already present, add() simply returns false:

System.out.println(set.add(1));  //true
System.out.println(set.add(2));  //true
System.out.println(set.add(3));  //true
System.out.println(set.add(1));  //false - as already present
 
//Note that the order of elements isn't guaranteed
System.out.println(set); //[1, 2, 3]

2. boolean contains(Object obj):

The contains() method returns true if the element exists in the referenced set, false otherwise:

System.out.println(set.contains(1)); //true
System.out.println(set.contains(4)); //false

3. boolean remove(Object obj):

As the name suggests, it removes the element obj if it exists and returns true. If no such element exists, it simply returns false:

System.out.println(set.remove(1)); //true
System.out.println(set.remove(4)); //false

Note that the HashSet also inherits removeAll() and removeIf() methods, which can be used to remove values.

4. boolean isEmpty():

It returns true for an empty set, false otherwise:

System.out.println(set.isEmpty()); // false

5. int size():

It simply returns the number of elements present in the given set.

6. void clear():

The clear() method removes all values present in the referenced set, thereby making it an empty set.

Internal Implementation:

A HashSet internally uses a HashMap to store its elements. The elements stored in a HashSet are mapped as the keys in a HashMap. The value fields of all these entries contain a constant PRESENT:

private static final Object PRESENT = new Object();

which is a dummy object.

Iterating Over HashSet:

We can use one of the following ways to iterate over the elements in a HashSet:

1. forEach():

Java 8 onwards, we can use forEach() to iterate over any Java Collection:

set.forEach(e -> System.out.println(e));

2. forEachRemaining():

Java 8 also supports forEachRemaining() construct to be used with any iterator over a Collection:

Iterator<Integer> itr = set.iterator();
 
itr.forEachRemaining(e -> System.out.println(e));

3. Iterate Using Iterator:

In case we’re on a Java 7 or lower versions, we can simply iterate through using an iterator:

Iterator<Integer> itr = set.iterator();
 
while(itr.hasNext()) {
    System.out.println(itr.next());
}

4. Extended for Loop:

We can also use an extended for loop to traverse through the elements:

for(Integer e : set) {
    System.out.println(e);
}

Conclusion:

In this tutorial, we learned how to create and work with a Java HashSet. We also know that the Java HashSet internally uses a HashMap for its implementation.

Be the First to comment.