Java 集合框架的HashSet类提供了哈希表数据结构的功能。
它实现了Set接口。
为了创建哈希集，我们必须首先导入java.util.HashSet包。
导入包后，就可以使用 Java 创建哈希集。
// HashSet with 8 capacity and 0.75 load factor
HashSet<Integer> numbers = new HashSet<>(8, 0.75); 在这里，我们创建了一个名为numbers的哈希集。
注意，新的HashSet<>(8, 0.75)部分。 在此，第一个参数是capcity，第二个参数是loadFactor。
capcity- 此哈希集的容量为 8。意味着，它可以存储 8 个元素。loadFactor- 此哈希集的负载因子为 0.6。 这意味着，只要我们的哈希集填充了 60%，元素就会移到新哈希表中，该哈希表的大小是原始哈希表的两倍。
默认容量和负载系数
创建哈希表而不定义其容量和负载因子是可能的。 例如，
// HashSet with default capacity and load factor
HashSet<Integer> numbers1 = new HashSet<>(); 默认，
- 哈希集的容量将为 16
- 负载系数将为 0.75
HashSet类提供了各种方法，使我们可以对设备执行各种操作。
add()- 将指定的元素插入到集合中addAll()- 将指定集合的所有元素插入集合
例如，
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> evenNumber = new HashSet<>();
// Using add() method
evenNumber.add(2);
evenNumber.add(4);
evenNumber.add(6);
System.out.println("HashSet: " + evenNumber);
HashSet<Integer> numbers = new HashSet<>();
// Using addAll() method
numbers.addAll(evenNumber);
numbers.add(5);
System.out.println("New HashSet: " + numbers);
}
} 输出
HashSet: [2, 4, 6]
New HashSet: [2, 4, 5, 6] 要访问哈希集的元素，我们可以使用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);
// Calling iterator() method
Iterator<Integer> iterate = numbers.iterator();
System.out.print("HashSet using Iterator: ");
// Accessing elements
while(iterate.hasNext()) {
System.out.print(iterate.next());
System.out.print(", ");
}
}
} 输出：
HashSet: [2, 5, 6]
HashSet using Iterator: 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);
// Using remove() method
boolean value1 = numbers.remove(5);
System.out.println("Is 5 removed? " + value1);
boolean value2 = numbers.removeAll(numbers);
System.out.println("Are all elements removed? " + value2);
}
} 输出：
HashSet: [2, 5, 6]
Is 5 removed? true
Are all elements removed? 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);
// Union of two set
numbers.addAll(evenNumbers);
System.out.println("Union is: " + numbers);
}
} 输出：
HashSet1: [2, 4]
HashSet2: [1, 3]
Union is: [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);
// Intersection of two sets
evenNumbers.retainAll(primeNumbers);
System.out.println("Intersection is: " + evenNumbers);
}
} 输出：
HashSet1: [2, 3]
HashSet2: [2, 4]
Intersection is: [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);
// Difference between HashSet1 and HashSet2
primeNumbers.removeAll(oddNumbers);
System.out.println("Difference : " + primeNumbers);
}
} 输出：
HashSet1: [2, 3, 5]
HashSet2: [1, 3, 5]
Difference: [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);
// Check if primeNumbers is a subset of numbers
boolean result = numbers.containsAll(primeNumbers);
System.out.println("Is HashSet2 is subset of HashSet1? " + result);
}
} 输出：
HashSet1: [1, 2, 3, 4]
HashSet2: [2, 3]
Is HashSet2 is a subset of HashSet1? true | 方法 | 描述 |
|---|---|
clone() |
创建HashSet的副本 |
contains() |
在HashSet中搜索指定的元素，并返回布尔结果 |
isEmpty() |
检查HashSet是否为空 |
size() |
返回HashSet的大小 |
clear() |
从HashSet中删除所有元素 |
要了解有关HashSet方法的更多信息，请访问 Java HashSet（Java 官方文档）。
在 Java 中，如果我们必须随机访问元素，则通常使用HashSet。 这是因为使用哈希码访问哈希表中的元素。
元素的哈希码是唯一的标识，有助于标识哈希表中的元素。
HashSet不能包含重复的元素。 因此，每个哈希集元素都有一个唯一的哈希码。
注意：哈希集未同步。 也就是说，如果多个线程同时访问哈希集，并且其中一个线程修改了哈希集。 然后，它必须在外部同步。