Set Interface in Java

Set Interface in Java: The Java Collections Framework is a fundamental and essential framework, and without any understanding those concepts, no one can do better programming. That’s why any strong Java developer should know like the back of their hand. In this post, we are going to learn one more interface of collection framework, which is the Set interface.

The topics which are going to discuss on this post is:

• Hierarchy of Set Interface
• Set interface in Java
• How to create a Set?
• Different Method of List Interface
• Set Implementations
• Different Operation On List Interface

Hierarchy of Set Interface

The Set interface extends the collection interface, whereas the collection interface extends the iterable interface. You can see the diagram of the complete Hierarchy of Set Interface for better understanding.

Set interface in Java

The set interface extends the collection interface. When there is a requirement is to store a group of the individual object as a single entity where duplicates are not allowed and insertion order not preserved then we should go for the List.

Like in List, Set interface does not have a particular order and also not provide control over the position of the elements.

How to create a Set?

We can define a new Set interface like below

Set<E> num = new HashSet<>();

We try to define the set generically, but if you want to specify with some specific type then you can mention like below

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

Different Methods Of Set Interface In Java

Like List interface, Set interface also so many methods, we try to share all those methods with the simple explanation in a tabular format below

Set Implementations

Different classes implement the Set interface in collection framework. That are HashSet, LinkedHashSet, or the TreeSet.

Each of these implementations acts differently while iterating the set, mostly concerning the ordering of the elements, and the time taken for insertion and for accessing the elements.

• HashSet does not maintain any order of the insertion of the elements, so when we try to retrieve the elements, also we do not get those elements in the same order as we have entered. We have discussed more details in a separate post on HashSet In Java, and you can read that too.
• LinkedHashSet is also implementing the set interface. Still, when we are trying to retrieve the elements by iterating those, then we get the elements as in the same order in which they have added. We can get this because LinkedHashSet implements the doubly linked list data structure. For more about the LinkedHashSet tutorial, you can read our detail post.
• TreeSet has also implemented the set interface, but it maintains the insertion order that is values are retrieved in the same order in which they are added. It uses a doubly linked list to obtain this functionality. For learn in details, you can check our details post about TreeSet class in Java.

Different Operation On List Interface

We are going to know about the essential operation like add, remove, Check the set is empty or not, Size of the set, Iterating the elements, Searching an element. And some other essential operation like union, Insertion, and Difference.

Add & Remove Operation In Set Interface:

By using the add() method we can add the elements into an Set Similarly with the help of Remove() method we can remove a specific element from the set also. You can check the below program for better understanding:

import java.util.*;
public class Main{
public static void main(String args[])
{
// Creating an Empty Set
Set<String> set = new HashSet<String>();

//Adding elements to the set
set.add(“John”);
set.add(“Doe”);

// Display the set
System.out.println(“Set: ” + set);

// Removing the element “Doe” using remove() method
set.remove(“Doe”);

// Displaying the modified set
System.out.println(“Set : ”
+ set);
}
}

Is Empty Method In Set Interface

This method helps us in check the Set is empty or not. If the Set in empty then it returns true and it returns false if the set has elements.

import java.io.*;
import java.util.*;

public class Main {
public static void main(String args[])
{
Set<String> javaSet = new HashSet<String>();

// Adding elements to the Set
javaSet.add(“John”);
javaSet.add(“Doe”);

// Display the set
System.out.println(“Set: ” + javaSet);

// Checking whether the set is empty
System.out.println(“Empty Set : ” + javaSet.isEmpty());

// Clearing the set using the clear() method
javaSet.clear();

// Checking whether the set is empty
System.out.println(“Empty Set : ” + javaSet.isEmpty());
}
}

Size Method

With the help of size() method, you can get the size of set which is the number of the elements present in the set.

import java.util.*;
public class Main {
public static void main(String args[])
{
// Creating a set
Set<String> set = new HashSet<String>();
set.add(“John”);
set.add(“Doe”);

System.out.println(“Set: ” + set);

// Displaying the size of the sent
System.out.println(“Size of the set : ” + set.size());
}
}

Iterating Over A Set

We can iterate the set elements by using the iterator.

import java.util.*;
import java.util.HashSet;

public class Main {
public static void main(String args[])
{
// Creating a HashSet
HashSet<String> javaSet = new HashSet<String>();

javaSet.add(“John”);
javaSet.add(“Doe”);

// Displaying the set
System.out.println(“HashSet: ” + javaSet);

// Creating an iterator
Iterator itr = javaSet.iterator();

// Displaying the values after iteration
System.out.println(“Iterator values: “);
while (itr.hasNext()) {
System.out.println(itr.next());
}
}
}

Searching in A Set

By using the contains () method in the set we can able to find out that the specific elements are present in the set or not. If the element is present in the set then you will get true and if the element is not presenyt then you will get false.

import java.io.*;
import java.util.HashSet;

public class Main {
public static void main(String args[])
{
// Creating a HashSet
HashSet<String> javaSet = new HashSet<String>();
javaSet.add(“John”);
javaSet.add(“Doe”);

// Displaying the HashSet
System.out.println(“HashSet: ” + javaSet);

// Checking for “John” in the set
System.out.println(“John in set: ” + javaSet.contains(“John”));

// Checking for “Hazel” in set
System.out.println(“Hazel in set: ” + javaSet.contains(“Hazel”));
}
}

Basic Operation On Sets in Java

As of now we have discussed about about thsoe methods which are acting on a single set but the set provides us some other methods which can act on m,ultiple methods those are :

• Union: We can use this operation to add one set with another.
• Intersection: Using this operation, we can able to get the common elements between the two sets.
• Difference: This operation remove the values of one set from the opther set. (For example, the set difference of s1 minus s2 is the set containing all of the elements found in s1 but not in s2.)

If you are still confused then check the below program so that you will get an clear idea:

import java.util.*;
public class Main
{
public static void main(String args[])
{
Set<Integer> d = new HashSet<Integer>();
d.addAll(Arrays.asList(new Integer[] {3, 2, 1, 9, 6, 4, 0}));
Set<Integer> e = new HashSet<Integer>();
e.addAll(Arrays.asList(new Integer[] {3, 1, 9, 5, 2, 0, 7,}));

// Union Operation
Set<Integer> union = new HashSet<Integer>(d);
union.addAll(e);
System.out.println(“Union :” + union);

// Intersection Operation
Set<Integer> intersection = new HashSet<Integer>(d);
intersection.retainAll(e);
System.out.println(“Intersection :” + intersection);

// Difference Operation
Set<Integer> difference = new HashSet<Integer>(d);
difference.removeAll(e);
System.out.println(“Difference :” + difference);
}
}

Important Points to Remember Java Set

In this section, we will discuss some of the important points about Java Set:

• Java Set interface is a member of the Java Collections Framework.
• Unlike List, Set DOES NOT allow you to add duplicate elements.
• The set allows you to add at most one null element only.
• Set interface got one default method in Java 8: spliterator.
• Unlike List and arrays, Set does NOT support indexes or positions of its elements.
• Set supports Generics, and we should use it whenever possible. Using Generics with Set will avoid ClassCastException at runtime.
• We can use Set interface implementations to maintain unique elements.

Ref: article