Java中的Set（如果想知道Java中有关Set的知识点，那么只看这一篇就足够了！）-天翼云

前言：在Java编程中，集合框架（Collections Framework）是处理数据结构和算法的基础工具之一。它提供了一套强大且灵活的接口和类，用于存储和操作不同类型的数据集合。在这其中，Set接口扮演着一个重要角色。与其他集合类型如List和Map不同，Set强调的是集合中元素的唯一性。这使得它在需要去重、快速查找等场景下显得尤为重要。

先让我们看一下本文大致的讲解内容：

1.Set概念的简介

（1）Set的定义

在Java中，Set接口是Java集合框架的一部分，用于表示一组唯一的元素。与List不同，Set不允许包含重复的元素。这意味着即使尝试将相同的元素添加多次，Set中也只会保留一个实例。Set接口继承自Collection接口，因此它也拥有一些集合框架中通用的方法。

Set的主要特点：

无序性：Set中的元素没有特定的顺序，这意味着你不能通过索引来访问Set中的元素。

唯一性：Set中的每个元素都是唯一的，即不能包含重复的元素。

允许null值：大多数Set实现都允许包含一个null值，但不能有多个null值。

我相信读者如果初次学习Java中的Set类的话，可能对上面对Java中Set类的解释不能够很好的理解，不过没有关系，读者继续向下阅读即可。

（2）Set类在Java集合类中的关系

了解了Set类的基本定义之后，现在再让我们看看Set类在Java的集合框架中的的关系，如下图：

Java中的Set（如果想知道Java中有关Set的知识点，那么只看这一篇就足够了！）

从上图我们可以得知，Java中的Set类也实现了Collection接口，那么Set类也就实现了Collection接口中的方法，即可以使用其中的方法。

——至此，通过上边的学习了解之后，这样我们就大致的了解了Java中的Set究竟是什么东西了。

2.Set接口中常用的API

在Java中，Set是继承自Collection的接口类，但是相较于Java中的Map类，Set中只存储了Key，所以对于Set而言，其方法大都是操作其中的Key的，以下是Set接口的主要方法：

方法	解释
boolean add(E e)	添加元素，但重复元素不会被添加成功
void clear()	清空集合
boolean contains(Object o)	判断 o 是否在集合中
Iterator<E> iterator()	返回迭代器
boolean remove(Object o)	删除集合中的 o
int size()	返回set中元素的个数
boolean isEmpty()	检测set是否为空，空返回true，否则返回false
Object[] toArray()	将set中的元素转换为数组返回
boolean containsAll(Collection<?> c)	集合c中的元素是否在set中全部存在，是返回true，否则返回 false
boolean addAll(Collection<? extends E> c)	将集合c中的元素添加到set中，可以达到去重的效果

这里我们对上述方法进行逐一使用代码进行实例解释：

（1）`boolean add(E e)`

——向集合中添加指定的元素。如果集合中不存在该元素，则返回true；如果集合中已存在该元素，则返回false。

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

public class AddExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        boolean added1 = set.add("Apple");
        boolean added2 = set.add("Banana");
        boolean added3 = set.add("Apple"); // 尝试添加重复元素

        System.out.println(set);
    }
}

输出：

[Apple, Banana]

（2）void clear()

——移除集合中的所有元素，使集合变为空集。

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

public class ClearExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");

        System.out.println("Set before clear: " + set);
        set.clear();
        System.out.println("Set after clear: " + set);
    }
}

输出：

Set before clear: [Apple, Banana, Cherry]
Set after clear: []

（3）boolean contains(Object o)

——如果集合中包含指定的元素，则返回true；否则返回false。

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

public class ContainsExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");

        boolean containsApple = set.contains("Apple");
        boolean containsCherry = set.contains("Cherry");

        System.out.println("Set contains 'Apple': " + containsApple);
        System.out.println("Set contains 'Cherry': " + containsCherry);
    }
}

输出：

Set contains 'Apple': true
Set contains 'Cherry': false

（4）Iterator<E> iterator()

——返回在集合中的元素上进行迭代的迭代器。

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

public class IteratorExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");

        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

输出：

Apple
Banana
Cherry

（5）boolean remove(Object o)

——从集合中移除指定的元素。如果集合中存在该元素，则返回true；否则返回false。

public class RemoveExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");

        boolean removed = set.remove("Banana");
        boolean notRemoved = set.remove("Cherry");

        System.out.println(set);
        System.out.println(removed);
        System.out.println(notRemoved);
    }
}

输出：

[Apple]
true
false

（6）int size()

——返回集合中元素的数量。

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

public class SizeExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");

        int size = set.size();
        System.out.println("Set size: " + size);
    }
}

输出：

Set size: 3

（7）boolean isEmpty()

——如果集合不包含任何元素，则返回true；否则返回false。

public class IsEmptyExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();

        boolean isEmptyBeforeAdd = set.isEmpty();
        set.add("Apple");
        boolean isEmptyAfterAdd = set.isEmpty();

        System.out.println(isEmptyBeforeAdd);
        System.out.println(isEmptyAfterAdd);
    }
}

输出：

true
false

（8）Object[] toArray()

——返回包含集合中所有元素的数组。

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

public class ToArrayExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");

        Object[] array = set.toArray();
        for (Object element : array) {
            System.out.println((String) element);
        }
    }
}

输出：

Apple
Banana
Cherry

（9）boolean containsAll(Collection<?> c)

——如果集合包含指定集合中的所有元素，则返回true；否则返回false。

public class ContainsAllExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");

        List<String> list = Arrays.asList("Apple", "Banana");

        boolean containsAll = set.containsAll(list);
        System.out.println(containsAll);
    }
}

输出：

true

（10）boolean addAll(Collection<? extends E> c)

——将指定集合中的所有元素添加到集合中。如果集合因调用而发生改变，则返回true。

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

public class AddAllExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");

        List<String> list = Arrays.asList("Banana", "Cherry", "Apple");

        boolean isChanged = set.addAll(list);
        System.out.println("Set after addAll: " + set);
        System.out.println("Was the set changed? " + isChanged);
    }
}

输出：

Set after addAll: [Apple, Banana, Cherry]
Was the set changed? true

这样我们就了解了Java中Set中常用的API了！

3.Set的常见实现类

Java中有几个常见的Set实现类，每个类都有其独特的特性和适用场景。以下是最常见的三种实现：

（1）HashSet

——HashSet是最常用的Set实现类之一。它基于哈希表实现，具有快速的插入、删除和查找操作。由于HashSet不维护元素的顺序，所以其遍历顺序可能与插入顺序不同。

以下为其使用代码：

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

public class HashSetExample {
    public static void main(String[] args) {
        Set<Integer> hashSet = new HashSet<>();
        hashSet.add(1);
        hashSet.add(2);
        hashSet.add(3);

        System.out.println("HashSet: " + hashSet);
    }
}

（2）LinkedHashSet

——LinkedHashSet是HashSet的子类，它维护着一个双向链表，以保证元素的插入顺序。因此，遍历LinkedHashSet时，元素将按照其插入顺序返回。

以下为其使用代码：

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

public class LinkedHashSetExample {
    public static void main(String[] args) {
        Set<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("One");
        linkedHashSet.add("Two");
        linkedHashSet.add("Three");

        System.out.println("LinkedHashSet: " + linkedHashSet);
    }
}

（3）TreeSet

——TreeSet实现了SortedSet接口，并基于红黑树实现。它保证元素按自然顺序或指定的比较器顺序排序。

以下为其使用代码：

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

public class TreeSetExample {
    public static void main(String[] args) {
        Set<String> treeSet = new TreeSet<>();
        treeSet.add("Banana");
        treeSet.add("Apple");
        treeSet.add("Cherry");

        System.out.println("TreeSet: " + treeSet);
    }
}

以上就是三种Java中常见的Set类的实现类了！

4.Set的实际案例

在日常的生活工作中，Java中的Set的用武之地还是有很多的，以下是一些实际使用Set的案例，展示了其在解决具体问题时的应用：

（1）去除重复元素

在数据处理中，通常需要去除重复的元素。Set的唯一性特性使其非常适合这个任务。

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

public class RemoveDuplicates {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "apple", "orange", "banana");
        Set<String> set = new HashSet<>(list);
        System.out.println("Unique elements: " + set);
    }
}

（2）查找集合的交集、并集和差集

我们还可以使用Set可以方便地进行集合操作，如交集、并集和差集。

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

public class SetOperations {
    public static void main(String[] args) {
        Set<String> set1 = new HashSet<>();
        set1.add("A");
        set1.add("B");
        set1.add("C");

        Set<String> set2 = new HashSet<>();
        set2.add("B");
        set2.add("C");
        set2.add("D");

        // 并集
        Set<String> union = new HashSet<>(set1);
        union.addAll(set2);
        System.out.println("Union: " + union);

        // 交集
        Set<String> intersection = new HashSet<>(set1);
        intersection.retainAll(set2);
        System.out.println("Intersection: " + intersection);

        // 差集
        Set<String> difference = new HashSet<>(set1);
        difference.removeAll(set2);
        System.out.println("Difference: " + difference);
    }
}

（3）判断两个集合是否相等

我们可以使用Set的equals方法来判断两个集合是否相等。两个集合相等的条件是它们包含的元素相同，顺序无关。

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

public class SetEquality {
    public static void main(String[] args) {
        Set<Integer> set1 = new HashSet<>();
        set1.add(1);
        set1.add(2);
        set1.add(3);

        Set<Integer> set2 = new HashSet<>();
        set2.add(3);
        set2.add(2);
        set2.add(1);

        System.out.println("Are sets equal? " + set1.equals(set2));
    }
}

当然，Java中的Set还有其他的许多用处，这里作者只是简单的列举出几点，其他的作用读者可以在日常中对其进行探索。这样我们就使用Set的实际案例来帮助你进一步理解Java中的Set类。

5.总结

在本文中，我们首先全面探讨了Java中的Set接口及其使用方法。Set是Java集合框架的重要组成部分，旨在存储唯一的元素。其主要特点包括元素的唯一性和无序性，使其在需要去重或处理集合操作时非常有用。

接着我们详细介绍了Set接口中的常用API，如add、clear、contains、iterator、remove、size、isEmpty、toArray、containsAll和addAll，并通过代码示例演示了这些方法的实际应用。

之后我们还讨论了HashSet、LinkedHashSet和TreeSet这几种常见的Set实现类，分析了它们的特点和适用场景。

最后通过实际案例，我们展示了如何利用Set解决实际编程问题，如去除重复元素、进行集合操作和判断集合相等。通过对Set的深入理解和实际应用，我们能够在开发中更高效地处理集合数据，提升代码的性能和可维护性。

活动

智算服务

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

Java中的Set（如果想知道Java中有关Set的知识点，那么只看这一篇就足够了！）

Java中的Set（如果想知道Java中有关Set的知识点，那么只看这一篇就足够了！）

1.Set概念的简介

（1）Set的定义

（2）Set类在Java集合类中的关系

2.Set接口中常用的API

（1）boolean add(E e)

（2）void clear()

（3）boolean contains(Object o)

（4）Iterator<E> iterator()

（5）boolean remove(Object o)

（6）int size()

（7）boolean isEmpty()

（8）Object[] toArray()

（9）boolean containsAll(Collection<?> c)

（10）boolean addAll(Collection<? extends E> c)

3.Set的常见实现类

（1）HashSet

（2）LinkedHashSet

（3）TreeSet

4.Set的实际案例

（1）去除重复元素

（2）查找集合的交集、并集和差集

（3）判断两个集合是否相等

5.总结

相关文章

Redis Set集合

jQuery遍历对象、数组、集合

【数据结构】详细介绍串的简单模式匹配——朴素模式匹配算法

计算机小白的成长历程——数组（1）

30天拿下Rust之向量

C++ 11新特性之tuple

arm架构下JAVA开发

数据结构-队列

Java实现根据概率中奖率怎么算

Java 代码本地设置Hadoop用户名密码

作者介绍

最新文章

Redis Set集合

【数据结构】详细介绍串的简单模式匹配——朴素模式匹配算法

C++ 11新特性之tuple

30天拿下Rust之向量

数据结构-队列

arm架构下JAVA开发

热门文章

Java线程同步synchronized wait notifyAll

Java/Android Annotation注解/注入（二）

Android/Java判断字符串String是否为float浮点数或double类型

Java小数点数字和百分号数字之间的转换

Java的自带注解Annotation(一)

Java/Android Annotation注解/注入（三）

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

serialVersionUID详解

Java中位运算符＞＞和＞＞＞的区别

Java之嵌套分支基本使用

【多线程】synchronized 中的 锁优化的机制 (偏向锁->轻量级锁->重量级锁)

Java中的常见数据结构及其实现

Java中的动态代理机制详解

（1）`boolean add(E e)`

【多线程】synchronized 中的锁优化的机制 (偏向锁->轻量级锁->重量级锁)