Set in Java

The set is an interface available in the java.util package. The set interface extends the Collection interface. An unordered collection or list in which duplicates are not allowed is referred to as a collection interface. The set interface is used to create the mathematical set. The set interface use collection interface's methods to avoid the insertion of the same elements. SortedSet and NavigableSet are two interfaces that extend the set implementation.

In the above diagram, the NavigableSet and SortedSet are both the interfaces. The NavigableSet extends the SortedSet, so it will not retain the insertion order and store the data in a sorted way.

SetExample1.java

import java.util.*; 
public class setExample{ 
    public static void main(String[] args) 
    { 
        // creating LinkedHashSet using the Set
        Set<String> data = new LinkedHashSet<String>(); 
  
        data.add("JavaTpoint"); 
        data.add("Set"); 
        data.add("Example"); 
        data.add("Set"); 
  
        System.out.println(data); 
    } 
} 

Output:

Note: Throughout the section, we have compiled the program with file name and run the program with class name. Because the file name and the class name are different.

Operations on the Set Interface

On the Set, we can perform all the basic mathematical operations like intersection, union and difference.

Suppose, we have two sets, i.e., set1 = [22, 45, 33, 66, 55, 34, 77] and set2 = [33, 2, 83, 45, 3, 12, 55]. We can perform the following operation on the Set:

Intersection: The intersection operation returns all those elements which are present in both the set. The intersection of set1 and set2 will be [33, 45, 55].
Union: The union operation returns all the elements of set1 and set2 in a single set, and that set can either be set1 or set2. The union of set1 and set2 will be [2, 3, 12, 22, 33, 34, 45, 55, 66, 77, 83].
Difference: The difference operation deletes the values from the set which are present in another set. The difference of the set1 and set2 will be [66, 34, 22, 77].

In set, addAll() method is used to perform the union, retainAll() method is used to perform the intersection and removeAll() method is used to perform difference. Let's take an example to understand how these methods are used to perform the intersection, union, and difference operations.

SetExample2.java

import java.util.*;  
public class SetOperations 
{  
    public static void main(String args[])  
    {  
        Integer[] A = {22, 45,33, 66, 55, 34, 77};
        Integer[] B = {33, 2, 83, 45, 3, 12, 55};
        Set<Integer> set1 = new HashSet<Integer>();  
        set1.addAll(Arrays.asList(A));  
        Set<Integer> set2 = new HashSet<Integer>();  
        set2.addAll(Arrays.asList(B));  
  
        // Finding Union of set1 and set2 
        Set<Integer> union_data = new HashSet<Integer>(set1);  
        union_data.addAll(set2);  
        System.out.print("Union of set1 and set2 is:");  
        System.out.println(union_data);  
  
        // Finding Intersection of set1 and set2  
        Set<Integer> intersection_data = new HashSet<Integer>(set1);  
        intersection_data.retainAll(set2);  
        System.out.print("Intersection of set1 and set2 is:");  
        System.out.println(intersection_data);  
  
        // Finding Difference of set1 and set2  
        Set<Integer> difference_data = new HashSet<Integer>(set1);  
        difference_data.removeAll(set2);  
        System.out.print("Difference of set1 and set2 is:");  
        System.out.println(difference_data);  
    }  
} 

Output:

Description:

In the above code, first, we create two arrays, i.e., A and B of type integer. After that, we create two set, i.e., set1 and set2 of type integer. We convert both the array into a list and add the elements of array A into set1 and elements of array B into set2.

For performing the union, we create a new set union_data with the same element of the set1. We then call the addAll() method of set and pass the set2 as an argument to it. This method will add all those elements to the union_data which are not present in it and gives the union of both sets.

For performing the intersection, we create a new set intersection_data with the same element of the set1. We then call the retainAll() method of set and pass the set2 as an argument to it. This method will get all those elements from the intersection_data which are present in set2 and store it in the intersection_data. Now, the intersection_data contains the intersect value of both the sets.

For performing the difference, we create a new set difference_data with the same element of the set1. We then call the removeAll() method of set and pass the set2 as an argument to it. This method will remove all those elements from the difference_data which are present in the set2 and gives the difference of both the sets.

Set Methods

There are several methods available in the set interface which we can use to perform a certain operation on our sets. These methods are as follows:

1) add()

The add() method insert a new value to the set. The method returns true and false depending on the presence of the insertion element. It returns false if the element is already present in the set and returns true if it is not present in the set.

Syntax:

SetExample3.java

import java.io.*; 
import java.util.*; 
public class addMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41); 
        data.add(11); 
        data.add(61); 
        data.add(51); 
        System.out.println("data: " + data); 
    } 
}

Output:

2) addAll()

The addAll() method appends all the elements of the specified collection to the set.

Syntax:

SetExample4.java

import java.io.*; 
import java.util.*;
class addAllMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41); 
        System.out.println("Set: " + data);
        ArrayList<Integer> newData = new ArrayList<Integer>(); 
        newData.add(91); 
        newData.add(71); 
        newData.add(81);
        data.addAll(newData); 
        System.out.println("Set: " + data);		
    } 
}

Output:

3) clear()

The method removes all the elements from the set. It doesn't delete the reference of the set. It only deletes the elements of the set.

Syntax:

SetExample5.java

import java.io.*; 
import java.util.*; 
public class clearMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
  
        data.add(31); 
        data.add(21); 
        data.add(41); 
        System.out.println("Set: " + data);
        
        data.clear(); 
        System.out.println("The final set: " + data); 
    } 
}

Output:

4) contains()

The contains() method is used to know the presence of an element in the set. Its return value is true or false depending on the presence of the element.

Syntax:

SetExample6.java

import java.io.*; 
import java.util.*; 
class containsMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41); 
        data.add(51); 
        data.add(11); 
        data.add(81); 
        System.out.println("Set: " + data);
        System.out.println("Does the Set contains '91'?" + data.contains(91)); 
        System.out.println("Does the Set contains 'javaTpoint'? " + data.contains("4"));
        System.out.println("Does the Set contains '51'? " + data.contains(51));
    } 
}

Output:

5) containsAll()

The method is used to check whether all the elements of the collection are available in the existing set or not. It returns true if all the elements of the collection are present in the set and returns false even if one of the elements is missing in the existing set.

Syntax:

SetExample7.java

import java.io.*; 
import java.util.*; 
class containsAllMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41); 
        data.add(51); 
        data.add(11); 
        data.add(81); 

        System.out.println("data: " + data);
		
        Set<Integer> newData = new LinkedHashSet<Integer>(); 
        newData.add(31); 
        newData.add(21); 
        newData.add(41); 
		
       System.out.println("\nDoes data contains newData?: "+ data.containsAll(newData));
		
    } 
}

Output:

6) hashCode()

The method is used to derive the hash code value for the current instance of the set. It returns hash code value of integer type.

Syntax:

SetExample8.java

import java.io.*; 
import java.util.*; 
class hashCodeMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41); 
        data.add(51); 
        data.add(11); 
        data.add(81); 
        System.out.println("data: " + data);
        System.out.println("\nThe hash code value of set is:"+ data.hashCode());	
    } 
}

Output:

7) isEmpty()

The isEmpty() method is used to identify the emptiness of the set . It returns true if the set is empty and returns false if the set is not empty.

Syntax:

SetExample9.java

import java.io.*; 
import java.util.*; 
class isEmptyMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41); 
        data.add(51); 
        data.add(11); 
        data.add(81); 
        System.out.println("data: " + data);
       System.out.println("\nIs data empty?: "+ data.isEmpty());	
    } 
}

Output:

8) iterator()

The iterator() method is used to find the iterator of the set. The iterator is used to get the element one by one.

Syntax:

SetExample10.java

import java.io.*; 
import java.util.*; 
class iteratorMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41); 
        data.add(51); 
        data.add(11); 
        data.add(81); 
        System.out.println("data: " + data);
		
        Iterator newData = data.iterator();
        System.out.println("The NewData values are: "); 
        while (newData.hasNext()) { 
            System.out.println(newData.next()); 
        }
    } 
}

Output:

9) remove()

The method is used to remove a specified element from the Set. Its return value depends on the availability of the element. It returns true if the element is available in the set and returns false if it is unavailable in the set.

Syntax:

SetExample11.java

import java.io.*; 
import java.util.*; 
class removeMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41); 
        data.add(51); 
        data.add(11); 
        data.add(81); 
        System.out.println("data: " + data);
        
        data.remove(81);
        data.remove(21);
        data.remove(11);	
        System.out.println("data after removing elements: " + data);
    } 
}

Output:

11) removeAll()

The method removes all the elements of the existing set from the specified collection.

Syntax:

SetExample12.java

import java.io.*; 
import java.util.*;
class removeAllMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41);
        data.add(91); 
        data.add(71); 
        data.add(81);		
        System.out.println("data: " + data);
		
        ArrayList<Integer> newData = new ArrayList<Integer>(); 
        newData.add(91); 
        newData.add(71); 
        newData.add(81);
        System.out.println("NewData: " + newData);
		
        data.removeAll(newData);
        System.out.println("data after removing Newdata elements : " + data);		
    } 
}

Output:

11) retainAll()

The method retains all the elements from the set specified in the given collection.

Syntax:

SetExample13.java

import java.io.*; 
import java.util.*;
class retainAllMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41);
        data.add(91); 
        data.add(71); 
        data.add(81);		
        System.out.println("data: " + data);
		
        ArrayList<Integer> newData = new ArrayList<Integer>(); 
        newData.add(91); 
        newData.add(71); 
        newData.add(81);
        System.out.println("newData: " + newData);
		
        data.retainAll(newData);	
        System.out.println("data after retaining newdata elements : " + data);		
    } 
}

Output:

12) size()

The method returns the size of the set.

Syntax:

SetExample14.java

import java.io.*; 
import java.util.*;
class sizeMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41);
        data.add(91); 
        data.add(71); 
        data.add(81);		
        System.out.println("data: " + data);
		
        System.out.println("size of the data is : " + data.size());		
    } 
}

Output:

13) removeAll()

The method is used to create an array with the same elements of the set.

Syntax:

SetExample15.java

import java.io.*; 
import java.util.*;
class toArrayMethod { 
    public static void main(String args[]) 
    { 
        Set<Integer> data = new LinkedHashSet<Integer>(); 
        data.add(31); 
        data.add(21); 
        data.add(41);
        data.add(91); 
        data.add(71); 
        data.add(81);		
        System.out.println("data: " + data);

        Object[] array_data = data.toArray(); 
        System.out.println("The array is:"); 
        for (int i = 0; i < array_data.length; i++) 
            System.out.println(array_data[i]);		
    } 
}

Output: