Java HashSet：唯一值、成员检查与集合运算

Set 存储唯一值

HashSet（来自 java.util）是一种集合，每个值最多只保存一次。它不像 HashMap 那样有键和值配对，只是一堆互不相同的元素。它的全部职责就是快速回答一个问题：“这个东西在不在里面？”

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("java");   // duplicate - ignored

        System.out.println(tags.contains("java"));     // true
        System.out.println(tags.contains("frontend")); // false
        System.out.println(tags.size());               // 2
    }
}

它只有一个类型参数 <ElementType>。和 ArrayList、HashMap 一样，通常把变量声明为 Set 接口类型，再构造一个 HashSet。

add 会告诉你值是不是新的

add 不只是存储值，它还会返回一个 boolean，告诉你集合是否真的发生了变化。添加一个已经存在的值会返回 false，集合保持不变。

import java.util.HashSet;
import java.util.Set;

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

        System.out.println(seen.add(7));  // true  - 7 was new
        System.out.println(seen.add(7));  // false - already there
        System.out.println(seen);
    }
}

这个返回值非常有用：if (!seen.add(x)) { /* x is a repeat */ } 让你在遍历的同时用一行代码检测出重复项。

给列表去重

因为集合会拒绝重复值，给一个集合类去重最快的方法就是把它整个倒进 Set 里。HashSet 的构造函数接受任何其他集合：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Ada", "Boris", "Ada", "Chen", "Boris"));

        Set<String> unique = new HashSet<>(names);
        System.out.println(unique);          // each name once
        System.out.println(unique.size());   // 3

        // need a List back?
        List<String> deduped = new ArrayList<>(unique);
        System.out.println(deduped.size());  // 3
    }
}

这是初学者用到 Set 最常见的原因。只是要知道，这样转一圈会丢失原来的顺序；如果顺序很重要，请用 LinkedHashSet（下文会讲）。

contains、remove 和 size

日常操作和其他集合类似：

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("api");

        System.out.println(tags.contains("api"));  // true
        System.out.println(tags.size());           // 3

        tags.remove("backend");
        System.out.println(tags.contains("backend")); // false

        tags.clear();
        System.out.println(tags.isEmpty());         // true
    }
}

相比 ArrayList，最大的优势在于 contains。列表必须逐个检查每个元素才能回答（O(n)）；HashSet 几乎能直接找到答案（大约 O(1)）。当你发现自己在循环里调用 list.contains(...) 时，通常就该换成 Set 了。

集合运算：并集、交集、差集

Set 的长处在于组合使用。只要分清每个方法对应哪种运算，读起来就像大白话：

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<Integer> a = new HashSet<>(Set.of(1, 2, 3, 4));
        Set<Integer> b = new HashSet<>(Set.of(3, 4, 5, 6));

        Set<Integer> union = new HashSet<>(a);
        union.addAll(b);            // everything in either set
        System.out.println(union);  // 1 2 3 4 5 6

        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);  // only what's in both
        System.out.println(intersection); // 3 4

        Set<Integer> difference = new HashSet<>(a);
        difference.removeAll(b);    // in a but not b
        System.out.println(difference);   // 1 2
    }
}

关键陷阱：addAll、retainAll 和 removeAll 会修改调用它们的那个集合。所以每个例子都先把 a 复制到一个新的 HashSet 里，否则你会毁掉原来的集合。每个结果都要新建一个集合。

HashSet 不保证顺序

和 HashMap 一样，HashSet 对遍历顺序不做任何保证，每次运行的顺序都可能不同。如果你需要可预测的顺序：

• LinkedHashSet 保留插入顺序，也就是你添加元素的顺序。
• TreeSet 让元素按自然顺序（或你提供的 Comparator）排序。

import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        Set<String> insertion = new LinkedHashSet<>();
        insertion.add("gamma");
        insertion.add("alpha");
        insertion.add("beta");
        System.out.println(insertion);  // [gamma, alpha, beta]

        Set<String> sorted = new TreeSet<>(insertion);
        System.out.println(sorted);      // [alpha, beta, gamma]
    }
}

三者都实现了 Set 接口，所以在它们之间切换只需改一行构造函数。

元素必须可哈希

HashSet 底层由 HashMap 支撑，所以规则相同：它通过哈希来定位元素，这意味着元素的 hashCode() 和 equals() 必须保持一致。String 和 Integer 等内置类型已经正确实现了这一点，所以上面重复的 "java" 字符串能被正确合并。如果你存放的是自己的类的实例，就要同时重写 equals 和 hashCode，否则两个在含义上“相等”的对象会被当成不同的对象，contains 和去重都会悄无声息地失效。

下一篇：遍历集合

你已经认识了三个最常用的集合：ArrayList、HashMap 和 HashSet。它们的遍历方式各有不同，还有一些不太明显的陷阱（比如在遍历集合时修改它）。下一篇会把这些串起来，讲解如何用 for-each 循环、迭代器和 forEach 干净地遍历集合。