In this lab, you will learn how to check if one set contains all elements of another set in Java. We will explore the containsAll() method, a convenient way to perform this subset check.
Through hands-on examples, you will learn how to use containsAll() with different set types and how to handle edge cases like empty and null sets.
In this step, we will explore how to check if one set is a subset of another using the containsAll() method in Java. This is a common operation when working with collections, and containsAll() provides a convenient way to perform this check.
First, let's create a new Java file named SubsetCheck.java in your ~/project directory. You can do this by right-clicking in the File Explorer on the left and selecting "New File", then typing SubsetCheck.java.
Now, open the SubsetCheck.java file in the editor and add the following code:
import java.util.HashSet;
import java.util.Set;
public class SubsetCheck {
public static void main(String[] args) {
// Create the main set
Set<Integer> mainSet = new HashSet<>();
mainSet.add(1);
mainSet.add(2);
mainSet.add(3);
mainSet.add(4);
mainSet.add(5);
// Create a potential subset
Set<Integer> subset = new HashSet<>();
subset.add(2);
subset.add(4);
// Check if 'subset' is a subset of 'mainSet'
boolean isSubset = mainSet.containsAll(subset);
// Print the result
System.out.println("Main Set: " + mainSet);
System.out.println("Subset: " + subset);
System.out.println("Is 'subset' a subset of 'mainSet'? " + isSubset);
}
}Let's break down the code:
import java.util.HashSet; and import java.util.Set;: These lines import the necessary classes for working with sets.Set<Integer> mainSet = new HashSet<>();: This creates a HashSet named mainSet that will store integer values.mainSet.add(...): These lines add elements to the mainSet.Set<Integer> subset = new HashSet<>();: This creates another HashSet named subset.subset.add(...): These lines add elements to the subset.boolean isSubset = mainSet.containsAll(subset);: This is the core of this step. The containsAll() method of the mainSet is called with subset as an argument. It returns true if mainSet contains all the elements of subset, and false otherwise.System.out.println(...): These lines print the sets and the result of the subset check to the console.Save the SubsetCheck.java file (Ctrl+S or Cmd+S).
Now, open the Terminal at the bottom of the WebIDE. Make sure you are in the ~/project directory. If not, use the command cd ~/project.
Compile the Java code using the javac command:
javac SubsetCheck.javaIf there are no errors, you should see no output. This means the compilation was successful and a SubsetCheck.class file has been created.
Finally, run the compiled Java program using the java command:
java SubsetCheckYou should see output similar to this:
Main Set: [1, 2, 3, 4, 5]
Subset: [2, 4]
Is 'subset' a subset of 'mainSet'? trueThis output confirms that the containsAll() method correctly identified that subset is indeed a subset of mainSet.
In the previous step, we used HashSet to demonstrate the containsAll() method. Java provides different implementations of the Set interface, such as HashSet, LinkedHashSet, and TreeSet. While they have different internal structures and properties (like order), the containsAll() method works consistently across them.
In this step, we will modify our SubsetCheck.java file to test containsAll() with different types of sets.
Open the SubsetCheck.java file in the WebIDE editor.
Replace the existing code with the following:
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
public class SubsetCheck {
public static void main(String[] args) {
// Create a main set using HashSet
Set<Integer> hashMainSet = new HashSet<>();
hashMainSet.add(10);
hashMainSet.add(20);
hashMainSet.add(30);
hashMainSet.add(40);
// Create a subset using LinkedHashSet
Set<Integer> linkedSubset = new LinkedHashSet<>();
linkedSubset.add(30);
linkedSubset.add(10);
// Create another subset using TreeSet
Set<Integer> treeSubset = new TreeSet<>();
treeSubset.add(40);
treeSubset.add(20);
// Check subset relationship using containsAll()
boolean isLinkedSubset = hashMainSet.containsAll(linkedSubset);
boolean isTreeSubset = hashMainSet.containsAll(treeSubset);
// Create a subset that is NOT a subset
Set<Integer> notSubset = new HashSet<>();
notSubset.add(20);
notSubset.add(50); // 50 is not in hashMainSet
boolean isNotSubset = hashMainSet.containsAll(notSubset);
// Print the results
System.out.println("Hash Main Set: " + hashMainSet);
System.out.println("Linked Subset: " + linkedSubset);
System.out.println("Is Linked Subset a subset of Hash Main Set? " + isLinkedSubset);
System.out.println("Tree Subset: " + treeSubset);
System.out.println("Is Tree Subset a subset of Hash Main Set? " + isTreeSubset);
System.out.println("Not Subset: " + notSubset);
System.out.println("Is Not Subset a subset of Hash Main Set? " + isNotSubset);
}
}In this updated code:
LinkedHashSet and TreeSet.hashMainSet using HashSet.linkedSubset using LinkedHashSet and treeSubset using TreeSet. Notice that the order of elements added to linkedSubset is different from how they appear in hashMainSet, but containsAll() still works correctly. TreeSet automatically sorts elements.notSubset to demonstrate a case where containsAll() returns false.Save the SubsetCheck.java file.
Now, compile the modified code in the Terminal:
javac SubsetCheck.javaIf the compilation is successful, run the program:
java SubsetCheckYou should see output similar to this:
Hash Main Set: [40, 10, 20, 30]
Linked Subset: [30, 10]
Is Linked Subset a subset of Hash Main Set? true
Tree Subset: [20, 40]
Is Tree Subset a subset of Hash Main Set? true
Not Subset: [50, 20]
Is Not Subset a subset of Hash Main Set? falseThis demonstrates that containsAll() works correctly regardless of the specific Set implementation used for the subset, as long as the main set contains all the elements of the subset.
In this final step, we will examine how the containsAll() method behaves when dealing with empty sets and null values. Understanding these edge cases is important for writing robust code.
Open the SubsetCheck.java file in the WebIDE editor.
Replace the existing code with the following:
import java.util.HashSet;
import java.util.Set;
public class SubsetCheck {
public static void main(String[] args) {
Set<Integer> mainSet = new HashSet<>();
mainSet.add(1);
mainSet.add(2);
mainSet.add(3);
// Case 1: Checking with an empty set
Set<Integer> emptySet = new HashSet<>();
boolean isEmptySubset = mainSet.containsAll(emptySet);
System.out.println("Main Set: " + mainSet);
System.out.println("Empty Set: " + emptySet);
System.out.println("Is Empty Set a subset of Main Set? " + isEmptySubset);
System.out.println("---"); // Separator
// Case 2: Checking if an empty set contains all elements of a non-empty set
Set<Integer> anotherEmptySet = new HashSet<>();
Set<Integer> nonEmptySet = new HashSet<>();
nonEmptySet.add(1);
boolean isEmptyContainingNonEmpty = anotherEmptySet.containsAll(nonEmptySet);
System.out.println("Another Empty Set: " + anotherEmptySet);
System.out.println("Non-Empty Set: " + nonEmptySet);
System.out.println("Is Another Empty Set a subset of Non-Empty Set? " + isEmptyContainingNonEmpty);
System.out.println("---"); // Separator
// Case 3: Checking with a null set
Set<Integer> nullSet = null;
try {
boolean isNullSubset = mainSet.containsAll(nullSet);
System.out.println("Is Null Set a subset of Main Set? " + isNullSubset);
} catch (NullPointerException e) {
System.out.println("Checking with a null set resulted in a: " + e.getClass().getName());
}
}
}Let's look at the new parts:
emptySet and check if mainSet contains all its elements. An empty set is considered a subset of any set, including another empty set.anotherEmptySet contains all elements of nonEmptySet. This should be false because the empty set does not contain the element 1.Set variable to null. Attempting to call containsAll() with a null argument will result in a NullPointerException. We use a try-catch block to handle this expected exception gracefully and print a message.Save the SubsetCheck.java file.
Compile the code in the Terminal:
javac SubsetCheck.javaRun the compiled program:
java SubsetCheckYou should see output similar to this:
Main Set: [1, 2, 3]
Empty Set: []
Is Empty Set a subset of Main Set? true
---
Another Empty Set: []
Non-Empty Set: [1]
Is Another Empty Set a subset of Non-Empty Set? false
---
Checking with a null set resulted in a: java.lang.NullPointerExceptionThis output confirms the behavior of containsAll() with empty and null sets:
true).false).null to containsAll() results in a NullPointerException.Understanding these cases helps you avoid potential errors when working with sets in Java.
In this lab, we learned how to check if one set contains all elements of another set in Java using the containsAll() method. We started by creating a basic example using HashSet to demonstrate the core functionality of containsAll(). This method provides a straightforward way to determine if a potential subset is indeed contained within a larger set.
We then explored how to test this functionality with different types of sets, understanding that containsAll() works consistently across various Set implementations. Finally, we addressed the important considerations of handling empty and null sets when performing subset checks, ensuring robust and error-free code.
