Set是不能包含重复元素的集合。它为数学集合抽象建模。Set接口仅包含从Collection继承的方法，并增加了禁止重复元素的限制。Set还为equals和hashCode操作的行为增加了更紧密的约定，允许Set实例进行有意义的比较，即使它们的实现类型不同。如果两个Set实例包含相同的元素，则它们相等。
Java平台包含三个泛型Set实现：HashSet，TreeSet，和LinkedHashSet。 HashSet将其元素存储在哈希表中，是性能最佳的实现。但是，它不能保证迭代的顺序。 TreeSet将其元素存储在红黑树中，根据其值对元素进行排序；它比HashSet慢得多。 LinkedHashSet实现为哈希表，并在其中运行链表，它根据元素插入到集合中的顺序（插入顺序）对元素进行排序。LinkedHashSet将其客户从HashSet提供的未指定的，通常是混乱的订购中省去了，但成本略高。
这是一个简单但有用的Set习语。假设您有一个Collection c，并且您想要创建一个包含相同元素但消除了所有重复项的另一个Collection。下面的单行代码可以解决问题。

  1. Collection<Type> noDups = new HashSet<Type>(c);

它通过创建一个Set（根据定义不能包含重复项）来工作，该Set最初包含c中的所有元素。 它使用“Collection接口”部分中描述的标准转换构造函数。
或者，如果使用JDK 8或更高版本，则可以使用聚合操作轻松地将其收集到Set中：

  1. c.stream()
  2. .collect(Collectors.toSet()); // no duplicates

这是一个稍长的示例，将名称Collection累积到一个TreeSet：

  1. Set<String> set = people.stream()
  2. .map(Person::getName)
  3. .collect(Collectors.toCollection(TreeSet::new));

以下是第一个惯用法的次要变体，它保留了原始集合的顺序，同时删除了重复的元素：

  1. Collection<Type> noDups = new LinkedHashSet<Type>(c);

以下是一种泛型方法，该方法封装了前面的习惯用法，返回与传递的泛型类型相同的泛型类型的Set。

  1. public static <E> Set<E> removeDups(Collection<E> c) {
  2.     return new LinkedHashSet<E>(c);
  3. }

set接口基本操作

size操作返回Set中元素的数量（其基数）。isEmpty方法完全符合您的预期。如果指定的元素尚不存在，则add方法将其添加到Set中，并返回一个布尔值，指示是否添加了该元素。同样，remove方法从Set中删除指定的元素（如果存在），并返回一个布尔值，指示该元素是否存在。 iterator方法在Set上返回一个Iterator。
下面的程序在其参数列表中打印出所有不同的词。提供了该程序的两个版本。第一种使用JDK 8聚合操作。第二个使用for-each构造。
使用JDK 8聚合操作：

  1. import java.util.*;
  2. import java.util.stream.*;
  4. public class FindDups {
  5.     public static void main(String[] args) {
  6.         Set<String> distinctWords = Arrays.asList(args).stream()
  7.         .collect(Collectors.toSet()); 
  8.         System.out.println(distinctWords.size()+ 
  9.                            " distinct words: " + 
  10.                            distinctWords);
  11.     }
  12. }

使用for-each构造：

  1. import java.util.*;
  3. public class FindDups {
  4.     public static void main(String[] args) {
  5.         Set<String> s = new HashSet<String>();
  6.         for (String a : args)
  7.                s.add(a);
  8.                System.out.println(s.size() + " distinct words: " + s);
  9.     }
  10. }

现在运行该程序的任何一个版本。

  1. java FindDups i came i saw i left

产生以下输出：

  1. 4 distinct words: [left, came, saw, i]

请注意，代码始终通过其接口类型（Set）而不是其实现类型来引用Collection。强烈建议您使用这种编程方法，因为它使您仅通过更改构造函数即可灵活地更改实现。如果声明用于存储集合的变量或用于传递集合的参数中的任何一个被声明为集合的实现类型，而不是其接口类型，则必须更改所有此类变量和参数，以更改其实现类型。
此外，不能保证所生成的程序将正常运行。如果程序使用原始实现类型中存在的任何非标准操作，而不是新实现类型中的任何非标准操作，则该程序将失败。仅通过集合的接口引用集合可以防止您使用任何非标准操作。
上一示例中Set的实现类型是HashSet，它不能保证Set中元素的顺序。如果要让程序按字母顺序打印单词列表，只需将Set的实现类型从HashSet更改为TreeSet。进行此单行琐碎的更改会使上一个示例中的命令行生成以下输出。

  1. java FindDups i came i saw i left
  3. 4 distinct words: [came, i, left, saw]

set接口批量操作

批量操作特别适合Set；应用时，它们执行标准的集合代数运算。假设s1和s2是集合。这是批量操作的作用：

  • s1.containsAll(s2)—如果s2是s1的子集，则返回true。（如果集合s1包含s2中的所有元素，则s2是s1的子集。）
  • s1.addAll(s2)—将s1转换为s1和s2的并集。（两个集合的并集是包含任何一个集合中包含的所有元素的集合。）
  • s1.retainAll(s2)—将s1转换为s1和s2的交集。（两个集合的交集是仅包含两个集合共有的元素的集合。）
  • s1.removeAll(s2)—将s1转换为s1和s2的（非对称）差集。 （例如，s1减去s2的差集就是包含在s1中，但不在s2中的所有元素的集合。）

为了无损地计算两个集合的并集，交集或差集（不修改任何一个集合），调用者必须在调用适当的批量操作之前复制一个集合。以下是结果习语。

  1. Set<Type> union = new HashSet<Type>(s1);
  2. union.addAll(s2);
  4. Set<Type> intersection = new HashSet<Type>(s1);
  5. intersection.retainAll(s2);
  7. Set<Type> difference = new HashSet<Type>(s1);
  8. difference.removeAll(s2);

前面习语中的结果Set的实现类型是HashSet，如上所述，它是Java平台中最好的全面Set实现。但是，可以替换任何泛型Set实现。
让我们重新访问FindDups程序。假设您想知道参数列表中的哪些单词仅出现一次，哪些单词不止一次出现，但是您不希望重复打印任何重复项。可以通过生成两个集合来实现此效果——一组包含参数列表中的每个单词，而另一组仅包含重复单词。仅出现一次的单词就是这两个集合的集合差异，我们知道如何计算。这是结果程序的样子。

  1. import java.util.*;
  3. public class FindDups2 {
  4.     public static void main(String[] args) {
  5.         Set<String> uniques = new HashSet<String>();
  6.         Set<String> dups    = new HashSet<String>();
  8.         for (String a : args)
  9.             if (!uniques.add(a))
  10.                 dups.add(a);
  12.         // Destructive set-difference
  13.         uniques.removeAll(dups);
  15.         System.out.println("Unique words:    " + uniques);
  16.         System.out.println("Duplicate words: " + dups);
  17.     }
  18. }

当使用与先前相同的参数列表（i came i saw i left）运行时，程序将产生以下输出。

  1. Unique words:    [left, saw, came]
  2. Duplicate words: [i]

较不常见的集合代数运算是对称集合差 -包含在两个指定集合中的任何一个中，但不在两个指定集合中的元素集合。以下代码无损地计算了两组对称集的差。

  1. Set<Type> symmetricDiff = new HashSet<Type>(s1);
  2. symmetricDiff.addAll(s2);
  3. Set<Type> tmp = new HashSet<Type>(s1);
  4. tmp.retainAll(s2);
  5. symmetricDiff.removeAll(tmp);

set接口数组操作

数组操作除了对其他Collection所做的之外，对Set并没有做任何特殊的事情。这些操作在“Collection接口”部分中进行了描述。