跳到主要内容

Java HashSet 类

提示
  1. HashSet创建和特性：HashSet类基于哈希表数据结构，实现了Set接口，用于存储不包含重复元素的集合，支持快速查找。
  2. HashSet的基本操作：HashSet提供了方法如add()、remove()和contains()等，用于插入、删除和检查元素，还包括集合运算方法如addAll()（并集）、retainAll()（交集）和removeAll()（差集）。
  3. HashSet的优势：使用HashSet适合随机访问场景，因为它通过元素的哈希码快速定位元素，但它不保证元素的顺序，并且不是线程同步的。

Java 集合框架的 HashSet 类提供了哈希表数据结构的功能。

它实现了 Set 接口。

Java HashSet 类实现了 Set 接口。

创建 HashSet​

要创建一个哈希集合，我们首先需要导入 java.util.HashSet 包。

一旦我们导入了包，下面是在 Java 中创建哈希集的方式。

// 容量为 8，加载因子为 0.75 的 HashSet
HashSet<Integer> numbers = new HashSet<>(8, 0.75);

这里，我们创建了一个名为 numbers 的哈希集。

注意，部分 new HashSet<>(8, 0.75)。这里，第一个参数是 容量，第二个参数是 加载因子。

  • 容量 - 这个哈希集的容量是 8。意味着，它可以存储 8 个元素。
  • 加载因子 - 这个哈希集的加载因子是 0.6。这意味着，每当我们的哈希集填满 60%，元素就会被移动到一个新的哈希表中，其大小是原始哈希表的两倍。

默认容量和加载因子

可以在不定义其容量和加载因子的情况下创建哈希表。例如，

// 默认容量和加载因子的 HashSet
HashSet<Integer> numbers1 = new HashSet<>();

默认情况下，

  • 哈希集的容量将为 16
  • 加载因子将为 0.75

HashSet 的方法​

HashSet 类提供了各种方法，允许我们对集合执行各种操作。

向 HashSet 中插入元素​

  • add() - 向集合中插入指定元素
  • addAll() - 将指定集合中的所有元素插入到集合中

例如，

import java.util.HashSet;

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

        // 使用 add() 方法
        evenNumber.add(2);
        evenNumber.add(4);
        evenNumber.add(6);
        System.out.println("HashSet: " + evenNumber);

        HashSet<Integer> numbers = new HashSet<>();

        // 使用 addAll() 方法
        numbers.addAll(evenNumber);
        numbers.add(5);
        System.out.println("新 HashSet: " + numbers);
    }
}

输出

HashSet: [2, 4, 6]
新 HashSet: [2, 4, 5, 6]

访问 HashSet 元素​

要访问哈希集的元素，我们可以使用 iterator() 方法。要使用这个方法，我们必须导入 java.util.Iterator 包。例如，

import java.util.HashSet;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("HashSet: " + numbers);

        // 调用 iterator() 方法
        Iterator<Integer> iterate = numbers.iterator();
        System.out.print("使用 Iterator 的 HashSet: ");
        // 访问元素
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

输出

HashSet: [2, 5, 6]
使用 Iterator 的 HashSet: 2, 5, 6,

删除元素​

  • remove() - 从集合中删除指定元素
  • removeAll() - 从集合中删除所有元素

例如，

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("HashSet: " + numbers);

        // 使用 remove() 方法
        boolean value1 = numbers.remove(5);
        System.out.println("5 被删除了吗？ " + value1);

        boolean value2 = numbers.removeAll(numbers);
        System.out.println("所有元素被删除了吗？ " + value2);
    }
}

输出

HashSet: [2, 5, 6]
5 被删除了吗？ true
所有元素被删除了吗？ true

集合运算​

HashSet 类的各种方法也可以用来执行各种集合运算。

集合的并集​

要执行两个集合之间的并集，我们可以使用 addAll() 方法。例如，

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> evenNumbers = new HashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("HashSet1: " + evenNumbers);

        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(1);
        numbers.add(3);
        System.out.println("HashSet2: " + numbers);

        // 两个集合的并集
        numbers.addAll(evenNumbers);
        System.out.println("并集是: " + numbers);
    }
}


输出

HashSet1: [2, 4]
HashSet2: [1, 3]
并集是: [1, 2, 3, 4]

集合的交集​

要执行两个集合之间的交集，我们可以使用 retainAll() 方法。例如

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> primeNumbers = new HashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("HashSet1: " + primeNumbers);

        HashSet<Integer> evenNumbers = new HashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("HashSet2: " + evenNumbers);

        // 两个集合的交集
        evenNumbers.retainAll(primeNumbers);
        System.out.println("交集是: " + evenNumbers);
    }
}

输出

HashSet1: [2, 3]
HashSet2: [2, 4]
交集是: [2]

集合的差集​

要计算两个集合之间的差集，我们可以使用 removeAll() 方法。例如，

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> primeNumbers = new HashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        primeNumbers.add(5);
        System.out.println("HashSet1: " + primeNumbers);

        HashSet<Integer> oddNumbers = new HashSet<>();
        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        System.out.println("HashSet2: " + oddNumbers);

        // HashSet1 和 HashSet2 之间的差集
        primeNumbers.removeAll(oddNumbers);
        System.out.println("差集是: " + primeNumbers);
    }
}

输出

HashSet1: [2, 3, 5]
HashSet2: [1, 3, 5]
差集是: [2]

子集​

要检查一个集合是否是另一个集合的子集，我们可以使用 containsAll() 方法。例如，

import java.util.HashSet;

class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("HashSet1: " + numbers);

        HashSet<Integer> primeNumbers = new HashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("HashSet2: " + primeNumbers);

        // 检查 primeNumbers 是否是 numbers 的子集
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("HashSet2 是否是 HashSet1 的子集？ " + result);
    }
}

输出

HashSet1: [1, 2, 3, 4]
HashSet2: [2, 3]
HashSet2 是否是 HashSet1 的子集？ true

HashSet 的其他方法​

方法描述
clone()创建 HashSet 的副本
contains()搜索指定元素是否存在于 HashSet 中，并返回布尔结果
isEmpty()检查 HashSet 是否为空
size()返回 HashSet 的大小
clear()从 HashSet 中删除所有元素

要了解更多关于 HashSet 方法的信息，请访问Java HashSet（官方 Java 文档）。

为什么使用 HashSet？​

在 Java 中，如果我们需要随机访问元素，通常会使用 HashSet。这是因为哈希表中的元素是通过哈希码来访问的。

元素的哈希码是一个唯一的标识，有助于在哈希表中识别元素。

HashSet 不能包含重复元素。因此，每个哈希集元素都具有唯一的哈希码。

注意： HashSet 不是线程同步的。如果多个线程同时访问哈希集，并且其中一个线程修改了哈希集，则必须进行外部同步。

最后于 更新