极客教程在Java中的Set接口
Set接口存在于java.util包中，扩展了Collection接口。它是一个无序对象的集合，不能存储重复的值。它是实现数学集合的接口。该接口包含从Collection接口继承的方法，并添加了一个限制插入重复元素的功能。有两个接口扩展了Set接口的实现，即SortedSet和NavigableSet。
在上面的图片中，NavigableSet接口扩展了SortedSet接口。由于集合不保留插入顺序，NavigableSet接口提供了通过Set导航的实现。实现NavigableSet的类是TreeSet，它是平衡树的实现。因此，此接口为我们提供了通过此树导航的方法。
声明： Set接口的声明如下：
public interface Set extends Collection
创建Set对象
由于Set是一个接口，因此不能创建Set类型的对象。我们总是需要一个扩展此列表的类来创建对象。而且，自Java 1.5引入泛型以来，可以限制可以存储在Set中的对象类型。可以将此类型安全的Set定义为：
// Obj是要存储在Set中的对象的类型
Set<Obj> set = new HashSet<Obj> ();
让我们以表格格式讨论Set接口中提供的方法，如下所示：
| 方法 | 描述 |
|---|---|
| add(element) | 此方法用于将特定元素添加到集合中。如果指定元素不在集合中，则将元素添加到集合中；否则，如果元素已在Set中，则该函数返回False。 |
| addAll(collection) | 此方法用于将指定集合中的所有元素追加到现有集合中。元素在添加时是随机的，没有遵循特定的顺序。 |
| clear() | 此方法用于从集合中删除所有元素，但不删除集合本身。仍然存在该集合的引用。 |
| contains(element) | 此方法用于检查是否存在指定的元素。 |
| containsAll(collection) | 此方法用于检查集合中是否包含指定集合中的所有元素。如果集合包含所有元素，则此方法返回true，否则返回false。 |
| hashCode() | 此方法用于获取此Set实例的hashCode值。它返回一个整数值，该值是Set实例的hashCode值。 |
| isEmpty() | 此方法用于检查集合是否为空。 |
| iterator() | 此方法用于返回集合的迭代器。迭代器返回的元素顺序是随机的。 |
| remove(element) | 此方法用于从集合中删除指定元素。如果指定元素在Set中，则返回True；否则返回False。 |
| removeAll(collection) | 此方法用于删除在集合中存在的集合中的所有元素。如果此集合因调用而发生更改，则此方法返回true。 |
| retainAll(collection) | 此方法用于保留集合中在给定的集合中提到的所有元素。如果此集合因调用而发生更改，则此方法返回true。 |
| size() | 此方法用于获取集合的大小。它返回一个整数值，该值表示元素的数量。 |
| toArray() | 此方法用于形成与Set相同元素的数组。 |
演示： 用于说明Set界面的示例程序
// Java程序说明Set接口
// 导入实用程序类
import java.util.*;
// 主类
public class GFG {
// 主驱动程序方法
public static void main(String[] args)
{
// 使用HashSet演示Set
// 声明类型为字符串的对象
Set<String> hash_Set = new HashSet<String>();
// 使用add()方法向集合中添加元素
hash_Set.add("Geeks");
hash_Set.add("For");
hash_Set.add("Geeks");
hash_Set.add("Example");
hash_Set.add("Set");
// 打印HashSet对象的元素
System.out.println(hash_Set);
}
}
输出
[Set，Example，Geeks，For]
Set 接口的操作
Set接口允许用户在集合上执行基本的数学运算。让我们拿两个数组来理解这些基本操作。假设set1 = [1, 3, 2, 4, 8, 9, 0]和set2 = [1, 3, 7, 5, 4, 0, 7, 5]。那么可以对集合执行以下操作：
1. 交集： 此操作返回给定两个集合中的所有共同元素。对于上述两个集合，交集将是：
Intersection = [0, 1, 3, 4]
2. 并集： 此操作将一个集合中的所有元素与另一个集合相加。对于上述两个集合，联合将是：
Union = [0, 1, 2, 3, 4, 5, 7, 8, 9]
3. 差集： 此操作从另一个集合中删除一个集合中存在的所有值。对于上述两个集合，差异将是：
Difference = [2, 8, 9]
现在让我们按照上述定义实现以下操作：
示例：
//Java程序演示集合（如union（并集），intersection（交集）和difference（差集）操作
//导入所有的实用程序类
import java.util.*;
//主类
public class SetExample {
//主驱动程序方法
public static void main(String args[])
{
//创建Set类的对象
//声明整数类型的对象
Set<Integer> a = new HashSet<Integer>();
//将所有元素添加到List中
a.addAll(Arrays.asList(
new Integer[] {1, 3, 2, 4, 8, 9, 0}));
//再次声明Set类对象
//参考HashSet
Set<Integer> b = new HashSet<Integer>();
b.addAll(Arrays.asList(
new Integer[] {1, 3, 7, 5, 4, 0, 7, 5}));
//查找联合
Set<Integer> union = new HashSet<Integer>(a);
union.addAll(b);
System.out.print("两个集合的联合");
System.out.println(union);
//查找交集
Set<Integer> intersection = new HashSet<Integer>(a);
intersection.retainAll(b);
System.out.print("两个集合的交集");
System.out.println(intersection);
//查找对称差异
Set<Integer> difference = new HashSet<Integer>(a);
difference.removeAll(b);
System.out.print("两个集合的差异");
System.out.println(difference);
}
}
输出
两个集合的联合[0, 1, 2, 3, 4, 5, 7, 8, 9]
两个集合的交集[0, 1, 3, 4]
两个集合的差异[2, 8, 9]
在SortedSet上执行各种操作
在Java 1.5中引入泛型之后，可以限制可以存储在Set中的对象类型。由于Set是一个接口，因此它只能与实现该接口的类一起使用。 HashSet是实现广泛使用实现Set接口的类之一。现在，让我们看看如何在HashSet上执行一些经常使用的操作。我们将执行以下操作：
- 添加元素
- 访问元素
- 删除元素
- 迭代元素
- 通过集合迭代
现在让我们逐个讨论这些操作：
操作1： 添加元素
为向Set添加元素，我们可以使用add()方法。但是，Set不保留插入顺序。在内部，对于每个元素，都生成一个哈希值，并按照生成的哈希值存储值。值按升序进行比较和排序。请注意，不允许重复元素，并且所有重复元素都被忽略。而且，Set接受空值。
示例
//使用add()方法添加元素演示Set的Java程序
//导入所有实用程序类
import java.util.*;
//主类
class GFG {
// 主驱动程序方法
public static void main(String[] args)
{
//创建Set对象并声明String类型的对象
Set<String> hs = new HashSet<String>();
//使用add()方法将元素添加到上述对象
hs.add("B");
hs.add("B");
hs.add("C");
hs.add("A");
//打印Set对象内的元素
System.out.println(hs);
}
}
输出
[A, B, C]
操作2： 访问元素
在添加元素之后，如果我们希望访问元素，则可以使用contains()等内置方法。
示例
// Java代码演示设置的工作方式
// 访问Set对象的元素
//导入所有实用程序类
import java.util.*;
//主类
class GFG {
// 主驱动程序方法
public static void main(String[] args)
{
//创建Set对象并声明String类型的对象
Set<String> hs = new HashSet<String>();
//使用add()方法添加元素
//随后我们将展示访问相同的内容
//定制输入元素
hs.add("A");
hs.add("B");
hs.add("C");
hs.add("A");
//打印Set对象的元素
System.out.println("Set is " + hs);
//声明一个字符串
String check = "D";
//使用contains()方法检查上述字符串是否存在于SortedSet中
System.out.println("Contains " + check + " "
+ hs.contains(check));
}
}
输出
Set is [A, B, C]
Contains D false
操作3： 删除值
可以使用remove()方法从Set中删除值。
示例
//使用remove()方法从Set中删除元素演示Java程序
//导入所有实用程序类
import java.util.*;
//主类
class GFG {
// 主驱动程序方法
public static void main(String[] args)
{
//声明String类型的Set对象
Set<String> hs = new HashSet<String>();
//使用add()方法添加元素
//定制输入元素
hs.add("A");
hs.add("B");
hs.add("C");
hs.add("B");
hs.add("D");
hs.add("E");
//打印初始Set对象的元素
System.out.println("Initial HashSet " + hs);
//使用remove()方法删除自定义元素
hs.remove("B");
//打印删除一个元素后的Set元素
//和更新后的Set元素
System.out.println("After removing element " + hs);
}
}
输出
初始 HashSet [A, B, C, D, E]
删除元素后 [A, C, D, E]
操作 4： 迭代 Set 集合
有许多迭代 Set 集合的方法。最常见的方法是使用增强的 for 循环。
示例
// Java 程序演示 Set 的迭代操作
// 导入工具类
import java.util.*;
// 主类
class GFG {
// 主驱动方法
public static void main(String[] args)
{
// 创建 Set 对象并声明类型为 String
Set<String> hs = new HashSet<String>();
// 添加元素到 Set 集合中
// 使用 add() 方法
// 自定义输入元素
hs.add("A");
hs.add("B");
hs.add("C");
hs.add("B");
hs.add("D");
hs.add("E");
// 迭代 Set 集合
// 使用增强的 for 循环
for (String value : hs)
// 打印对象中的所有值
System.out.print(value + ", ");
System.out.println();
}
}
输出
A, B, C, D, E,
Java 集合中实现 Set 接口的类可以从以下图片中轻松地了解并列出如下：
- HashSet
- EnumSet
- LinkedHashSet
- TreeSet
类 1： HashSet ****
实现集合框架中 HashSet 类是哈希表数据结构的内在实现。我们插入 HashSet 中的对象不能保证以相同的顺序插入。这些对象是根据它们的哈希码插入的。此类也允许插入空元素。让我们看一下如何使用此类创建 set 对象。
示例
// Java 程序演示如何使用 HashSet 类创建 Set 对象
// 导入工具类
import java.util.*;
// 主类
class GFG {
// 主驱动方法
public static void main(String[] args)
{
// 创建类型为 String 的 Set 对象
Set<String> h = new HashSet<String>();
// 使用 add() 方法添加元素到 HashSet 集合中
// 自定义输入元素
h.add("India");
h.add("Australia");
h.add("South Africa");
// 添加重复元素
h.add("India");
// 显示 HashSet
System.out.println(h);
// 使用 remove() 方法从 HashSet 中删除元素
h.remove("Australia");
System.out.println("移除 Australia 后 Set:" + h);
// 迭代 HashSet 集合中的元素
System.out.println("迭代集合：");
// 使用迭代器进行迭代
Iterator<String> i = h.iterator();
// 只要对象中还剩下一个元素，它就保持 true
while (i.hasNext())
System.out.println(i.next());
}
}
输出
[South Africa, Australia, India]
移除 Australia 后 Set:[South Africa, India]
迭代集合：
South Africa
India
类 2： EnumSet
EnumSet类是集合框架中实现的专用Set接口实现之一，用于枚举类型。它是一种高性能的Set实现，比HashSet快得多。枚举集合中的所有元素必须来自在创建集合时显式或隐式指定的单个枚举类型。让我们看看如何使用这个类创建一个集合对象。
示例
// Java程序演示创建
//使用EnumSet类的集合对象
import java.util.*;
enum Gfg { CODE, LEARN, CONTRIBUTE, QUIZ, MCQ }
;
public class GFG {
public static void main(String[] args)
{
// 创建一个集合对象
Set<Gfg> set1;
// 添加元素
set1 = EnumSet.of(Gfg.QUIZ, Gfg.CONTRIBUTE,
Gfg.LEARN, Gfg.CODE);
System.out.println("Set 1: " + set1);
}
}
输出
Set 1: [CODE, LEARN, CONTRIBUTE, QUIZ]
类3: LinkedHashSet
LinkedHashSet类是集合框架中实现的HashSet的有序版本，它在所有元素之间维护一个双向链表。当需要维护迭代顺序时，使用此类。在遍历HashSet时，顺序是不可预测的，而LinkedHashSet使我们可以按插入顺序遍历元素。让我们看看如何使用这个类创建一个集合对象。
示例
// Java程序演示创建Set对象
//使用LinkedHashset类
import java.util.*;
class GFG {
public static void main(String[] args)
{
Set<String> lh = new LinkedHashSet<String>();
// 使用add()向LinkedHashSet添加元素
lh.add("India");
lh.add("Australia");
lh.add("South Africa");
// 添加重复的元素
lh.add("India");
// 显示LinkedHashSet
System.out.println(lh);
// 使用remove()从LinkedHashSet中删除项目
lh.remove("Australia");
System.out.println("Set after removing "
+ "Australia:" + lh);
// 遍历链式哈希集项
System.out.println("Iterating over set:");
Iterator<String> i = lh.iterator();
while (i.hasNext())
System.out.println(i.next());
}
}
输出
[India, Australia, South Africa]
Set after removing Australia:[India, South Africa]
Iterating over set:
India
South Africa
类4: TreeSet
TreeSet类是集合框架中实现的SortedSet接口和SortedSet扩展Set接口的实现。它的行为类似于一个简单的集合，但它以排序的格式存储元素。 TreeSet使用树结构进行存储。对象按升序排序存储。但是我们可以使用TreeSet.descendingIterator（）方法按降序迭代。让我们看看如何使用这个类创建一个集合对象。
示例
// Java程序演示创建Set对象
// 使用TreeSet类
// 导入实用类
import java.util.*;
// 主类
class GFG {
// 主驱动器方法
public static void main(String[] args)
{
// 创建Set对象，并将其声明为String类型，
// 使用TreeSet引用
Set<String> ts = new TreeSet<String>();
// 使用add()将元素添加到TreeSet中
ts.add("India");
ts.add("Australia");
ts.add("South Africa");
// 添加重复的元素
ts.add("India");
// 显示TreeSet
System.out.println(ts);
// 使用remove()从TreeSet中删除项
ts.remove("Australia");
System.out.println("删除Australia后的集合:" + ts);
// 迭代树集项目
System.out.println("迭代集合:");
Iterator<String> i = ts.iterator();
while (i.hasNext())
System.out.println(i.next());
}
}
输出
[Australia, India, South Africa]
删除Australia后的集合:[India, South Africa]
迭代集合:
India
South Africa