![8/30/2016 The Set Interface (The Java™ Tutorials > Collections > Interfaces)
https://docs.oracle.com/javase/tutorial/collections/interfaces/set.html 2/3
import java.util.*;
import java.util.stream.*;
public class FindDups {
public static void main(String[] args) {
Set<String> distinctWords = Arrays.asList(args).stream()
.collect(Collectors.toSet());
System.out.println(distinctWords.size()+
" distinct words: " +
distinctWords);
}
}
Using the foreach Construct:
import java.util.*;
public class FindDups {
public static void main(String[] args) {
Set<String> s = new HashSet<String>();
for (String a : args)
s.add(a);
System.out.println(s.size() + " distinct words: " + s);
}
}
Now run either version of the program.
java FindDups i came i saw i left
The following output is produced:
4 distinct words: [left, came, saw, i]
Note that the code always refers to the Collection by its interface type (Set) rather than by its implementation type. This is a strongly
recommended programming practice because it gives you the flexibility to change implementations merely by changing the constructor. If either of the
variables used to store a collection or the parameters used to pass it around are declared to be of the Collection's implementation type rather than
its interface type, all such variables and parameters must be changed in order to change its implementation type.
Furthermore, there's no guarantee that the resulting program will work. If the program uses any nonstandard operations present in the original
implementation type but not in the new one, the program will fail. Referring to collections only by their interface prevents you from using any
nonstandard operations.
The implementation type of the Set in the preceding example is HashSet, which makes no guarantees as to the order of the elements in the Set. If
you want the program to print the word list in alphabetical order, merely change the Set's implementation type from HashSet to TreeSet. Making
this trivial oneline change causes the command line in the previous example to generate the following output.
java FindDups i came i saw i left
4 distinct words: [came, i, left, saw]
Set Interface Bulk Operations
Bulk operations are particularly well suited to Sets; when applied, they perform standard setalgebraic operations. Suppose s1 and s2 are sets.
Here's what bulk operations do:
s1.containsAll(s2) — returns true if s2 is a subset of s1. (s2 is a subset of s1 if set s1 contains all of the elements in s2.)
s1.addAll(s2) — transforms s1 into the union of s1 and s2. (The union of two sets is the set containing all of the elements contained in
either set.)
s1.retainAll(s2) — transforms s1 into the intersection of s1 and s2. (The intersection of two sets is the set containing only the
elements common to both sets.)
s1.removeAll(s2) — transforms s1 into the (asymmetric) set difference of s1 and s2. (For example, the set difference of s1 minus s2 is
the set containing all of the elements found in s1 but not in s2.)
To calculate the union, intersection, or set difference of two sets nondestructively (without modifying either set), the caller must copy one set before
calling the appropriate bulk operation. The following are the resulting idioms.](https://image.slidesharecdn.com/thesetinterfacethejavatutorialscollectionsinterfaces-161008062606/85/The-set-interface-the-java-tutorials-collections-interfaces-2-320.jpg)
![8/30/2016 The Set Interface (The Java™ Tutorials > Collections > Interfaces)
https://docs.oracle.com/javase/tutorial/collections/interfaces/set.html 3/3
Set<Type> union = new HashSet<Type>(s1);
union.addAll(s2);
Set<Type> intersection = new HashSet<Type>(s1);
intersection.retainAll(s2);
Set<Type> difference = new HashSet<Type>(s1);
difference.removeAll(s2);
The implementation type of the result Set in the preceding idioms is HashSet, which is, as already mentioned, the best allaround Set
implementation in the Java platform. However, any generalpurpose Set implementation could be substituted.
Let's revisit the FindDups program. Suppose you want to know which words in the argument list occur only once and which occur more than once,
but you do not want any duplicates printed out repeatedly. This effect can be achieved by generating two sets — one containing every word in the
argument list and the other containing only the duplicates. The words that occur only once are the set difference of these two sets, which we know
how to compute. Here's how the resulting program looks.
import java.util.*;
public class FindDups2 {
public static void main(String[] args) {
Set<String> uniques = new HashSet<String>();
Set<String> dups = new HashSet<String>();
for (String a : args)
if (!uniques.add(a))
dups.add(a);
// Destructive set‐difference
uniques.removeAll(dups);
System.out.println("Unique words: " + uniques);
System.out.println("Duplicate words: " + dups);
}
}
When run with the same argument list used earlier (i came i saw i left), the program yields the following output.
Unique words: [left, saw, came]
Duplicate words: [i]
A less common setalgebraic operation is the symmetric set difference — the set of elements contained in either of two specified sets but not in both.
The following code calculates the symmetric set difference of two sets nondestructively.
Set<Type> symmetricDiff = new HashSet<Type>(s1);
symmetricDiff.addAll(s2);
Set<Type> tmp = new HashSet<Type>(s1);
tmp.retainAll(s2);
symmetricDiff.removeAll(tmp);
Set Interface Array Operations
The array operations don't do anything special for Sets beyond what they do for any other Collection. These operations are described in The
Collection Interface section.
Your use of this page and all the material on pages under "The Java Tutorials" banner is subject to these legal
notices.
Copyright © 1995, 2015 Oracle and/or its affiliates. All rights reserved.
Problems with the examples? Try Compiling and Running the Examples:
FAQs.
Complaints? Compliments? Suggestions? Give us your feedback.
Previous page: The Collection Interface
Next page: The List Interface](https://image.slidesharecdn.com/thesetinterfacethejavatutorialscollectionsinterfaces-161008062606/85/The-set-interface-the-java-tutorials-collections-interfaces-3-320.jpg)
The set interface (the java™ tutorials collections interfaces)
- 2. 8/30/2016 The Set Interface (The Java™ Tutorials > Collections > Interfaces) https://docs.oracle.com/javase/tutorial/collections/interfaces/set.html 2/3 import java.util.*; import java.util.stream.*; public class FindDups { public static void main(String[] args) { Set<String> distinctWords = Arrays.asList(args).stream() .collect(Collectors.toSet()); System.out.println(distinctWords.size()+ " distinct words: " + distinctWords); } } Using the foreach Construct: import java.util.*; public class FindDups { public static void main(String[] args) { Set<String> s = new HashSet<String>(); for (String a : args) s.add(a); System.out.println(s.size() + " distinct words: " + s); } } Now run either version of the program. java FindDups i came i saw i left The following output is produced: 4 distinct words: [left, came, saw, i] Note that the code always refers to the Collection by its interface type (Set) rather than by its implementation type. This is a strongly recommended programming practice because it gives you the flexibility to change implementations merely by changing the constructor. If either of the variables used to store a collection or the parameters used to pass it around are declared to be of the Collection's implementation type rather than its interface type, all such variables and parameters must be changed in order to change its implementation type. Furthermore, there's no guarantee that the resulting program will work. If the program uses any nonstandard operations present in the original implementation type but not in the new one, the program will fail. Referring to collections only by their interface prevents you from using any nonstandard operations. The implementation type of the Set in the preceding example is HashSet, which makes no guarantees as to the order of the elements in the Set. If you want the program to print the word list in alphabetical order, merely change the Set's implementation type from HashSet to TreeSet. Making this trivial oneline change causes the command line in the previous example to generate the following output. java FindDups i came i saw i left 4 distinct words: [came, i, left, saw] Set Interface Bulk Operations Bulk operations are particularly well suited to Sets; when applied, they perform standard setalgebraic operations. Suppose s1 and s2 are sets. Here's what bulk operations do: s1.containsAll(s2) — returns true if s2 is a subset of s1. (s2 is a subset of s1 if set s1 contains all of the elements in s2.) s1.addAll(s2) — transforms s1 into the union of s1 and s2. (The union of two sets is the set containing all of the elements contained in either set.) s1.retainAll(s2) — transforms s1 into the intersection of s1 and s2. (The intersection of two sets is the set containing only the elements common to both sets.) s1.removeAll(s2) — transforms s1 into the (asymmetric) set difference of s1 and s2. (For example, the set difference of s1 minus s2 is the set containing all of the elements found in s1 but not in s2.) To calculate the union, intersection, or set difference of two sets nondestructively (without modifying either set), the caller must copy one set before calling the appropriate bulk operation. The following are the resulting idioms.