Java基础 - 07 Set之Set，AbstractSet

上边几篇，我们对java的List集合进行相关介绍，了解了关于List集合下的相关实现类的方法或者接口。

自本篇开始，将围绕java的Set进行介绍，也是对我java知识的巩固吧，处理业务越多，发现自己对基础知识的薄弱，于是又回头继续学习，没办法，学习就是这样，忘记又学，学了又忘，听他们说，把东西理解了，并掺杂自己的想法就不会忘记了，我也不知道是不是真的，算了废话不多说了，开始介绍Set集合了；

Set集合

Set作为Java中的一个接口，它继承自Collection接口，用于存储不重复的元素， Set不保证元素的顺序，且不允许包含重复元素。

Set的特点包括：

• 不允许重复的元素： set中的元素是唯一的，如果试图向Set中添加重复的元素，则添加操作将被忽略。

• 具备无序性： Set中的元素没有固定的顺序，不同的实现类可能以不同的方式存储和遍历元素。

• 具备高效性： Set提供了高效的元素查找和插入操作，通常使用哈希表或者树等数据结构来实现。

Set定义的常用的方法，例如

• 添加元素：add(element)：向Set中添加指定元素。
• 删除元素：remove(element)：从Set中移除指定元素。
• 判断是否包含元素：contains(element)：判断Set中是否包含指定元素。
• 获取元素个数：size()：返回Set中元素的个数。
• 清空Set：clear()：移除Set中的所有元素。
• 遍历Set：可以使用迭代器或增强for循环来遍历Set中的元素。

public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        // 添加元素
        set.add("apple");
        set.add("banana");
        set.add("orange");
        set.add("apple"); // 重复元素，将被忽略
        // 判断是否包含元素
        System.out.println(set.contains("apple")); // 输出：true
        System.out.println(set.contains("grape")); // 输出：false
        // 获取元素个数
        System.out.println(set.size()); // 输出：3
        // 遍历Set
        for (String element : set) {
            System.out.println(element);
        }
        // 删除元素
        set.remove("banana");
        // 清空Set
        set.clear();
    }

注意一下，Set重写了equals和hashCode方法。

用途：

• 去重：当需要从一组数据中去除重复元素时，可以使用Set来存储数据，因为Set会自动去除重复元素。

• 查找：由于Set内部使用哈希表或树等数据结构实现，查找操作的时间复杂度为O(1)或O(log n)，因此在需要快速查找元素的场景下，Set是一个很好的选择。

• 数学集合运算：Set提供了一些集合运算的方法，如交集、并集、差集等，可以方便地进行集合操作。

Set的优点：

• 去重功能：Set保证元素的唯一性，可以自动去除重复元素，简化了去重操作。
• 高效的查找和插入操作：Set的底层实现通常使用哈希表或树等数据结构，使得查找和插入操作具有高效性。
• 提供了集合运算方法：Set提供了一些集合运算的方法，方便进行集合操作。

Set的缺点：

• 无序性：Set中的元素没有固定的顺序，无法按照特定的顺序进行访问和遍历。

• 不支持索引访问：Set接口不提供索引访问元素的方法，无法通过索引直接访问元素，需要使用迭代器或其他方式进行遍历。

• 内存占用较大：由于Set需要保证元素的唯一性，可能需要额外的内存空间来存储哈希值或比较元素，因此在存储大量数据时，可能会占用较多的内存。

举例说明

交集（Intersection）：获取两个Set中共同存在的元素。

Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));

Set<Integer> intersection = new HashSet<>(set1);
intersection.retainAll(set2);

System.out.println(intersection); // 输出：[4, 5]

创建了两个Set，分别包含一些整数元素。然后，我们创建一个新的Set ntersection，并将其初始化为set1的副本。接下来，我们使用retainAll()方法将intersection与set2取交集，最终得到的结果是[4, 5]，即两个Set中共同存在的元素。

并集（Union）：获取两个Set中所有的不重复元素。

Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));

Set<Integer> union = new HashSet<>(set1);
union.addAll(set2);

System.out.println(union); // 输出：[1, 2, 3, 4, 5, 6, 7, 8]

我们创建了两个Set，分别包含一些整数元素。然后，我们创建一个新的Set union，并将其初始化为set1的副本。接下来，我们使用addAll()方法将set2中的元素添加到union中，最终得到的结果是[1, 2, 3, 4, 5, 6, 7, 8]，即两个Set中所有的不重复元素。

差集（Difference）：获取在第一个Set中存在但在第二个Set中不存在的元素。

Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
Set<Integer> set2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8));

Set<Integer> difference = new HashSet<>(set1);
difference.removeAll(set2);

System.out.println(difference); // 输出：[1, 2, 3]

我们创建了两个Set，分别包含一些整数元素。然后，我们创建一个新的Set difference，并将其初始化为set1的副本。接下来，我们使用removeAll()方法将set2中的元素从difference中移除，最终得到的结果是[1, 2, 3]，即在第一个Set中存在但在第二个Set中不存在的元素。

AbstractSet< E >

AbstractSet是一个抽象类，它实现了Set接口的大部分方法，提供了一些通用的实现，使得编写自定义的Set实现类变得更加简单。

相关方法

add(E e)：向集合中添加指定的元素。默认实现会抛出UnsupportedOperationException异常，因此，具体的子类需要重写该方法来实现添加元素的逻辑。

addAll(Collection<? extends E> c)：将指定集合中的所有元素添加到当前集合中。默认实现会遍历指定集合，并逐个调用add()方法来添加元素。

clear()：从集合中移除所有的元素。默认实现会遍历集合，并逐个调用remove()方法来移除元素。

contains(Object o)：判断集合是否包含指定的元素。默认实现会遍历集合，并逐个调用equals()方法来比较元素。

containsAll(Collection<?> c)：判断集合是否包含指定集合中的所有元素。默认实现会遍历指定集合，并逐个调用contains()方法来判断元素是否存在。

equals(Object o)：判断当前集合是否与指定对象相等。默认实现会比较集合的大小和元素是否相同。

hashCode()：返回当前集合的哈希码值。默认实现会遍历集合，并累加每个元素的哈希码值。

isEmpty()：判断集合是否为空。默认实现会判断集合的大小是否为0。

iterator()：返回一个用于遍历集合的迭代器。默认实现会返回AbstractSet的内部类Iterator的实例。

remove(Object o)：从集合中移除指定的元素。默认实现会遍历集合，并逐个调用equals()方法来比较元素。

removeAll(Collection<?> c)：从集合中移除指定集合中的所有元素。默认实现会遍历指定集合，并逐个调用remove()方法来移除元素。

retainAll(Collection<?> c)：仅保留集合中与指定集合中相同的元素，移除其他元素。默认实现会遍历集合，并逐个调用contains()方法来判断元素是否存在。

size()：返回集合中的元素个数。默认实现会遍历集合并计数。

toArray()：将集合转换为数组。默认实现会创建一个新的数组，并将集合中的元素复制到数组中。

案例

AbstractSet在Java中的作用是为自定义的Set实现类提供了一些通用的方法实现，简化了编写Set实现类的过程。通过继承AbstractSet，我们只需要关注实现自定义的Set特有的方法，而无需重复编写已经在AbstractSet中实现的方法。

public class MySet<E> extends AbstractSet<E> {
    private Object[] elements;
    private int size;

    public MySet() {
        elements = new Object[10];
        size = 0;
    }

    @Override
    public boolean add(E e) {
        if (contains(e)) {
            return false;
        }
        if (size >= elements.length) {
            // 扩容数组
            Object[] newElements = new Object[elements.length * 2];
            System.arraycopy(elements, 0, newElements, 0, size);
            elements = newElements;
        }
        elements[size++] = e;
        return true;
    }

    @Override
    public Iterator<E> iterator() {
        return new MySetIterator();
    }

    @Override
    public int size() {
        return size;
    }

    private class MySetIterator implements Iterator<E> {
        private int cursor;

        @Override
        public boolean hasNext() {
            return cursor < size;
        }

        @Override
        public E next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return (E) elements[cursor++];
        }
    }
}

我们创建了一个名为MySet的自定义Set实现类，它继承自AbstractSet。我们只需要实现add()、iterator()和size()这三个抽象方法，而其他方法如contains()、remove()等已经在AbstractSet中实现了。

在MySet中，我们使用一个数组elements来存储集合中的元素，size表示集合的大小。在add()方法中，我们首先判断元素是否已经存在于集合中，如果存在则返回false，否则将元素添加到数组中。如果数组已满，则扩容数组。在iterator()方法中，我们返回一个内部类MySetIterator的实例，用于遍历集合中的元素。在size()方法中，我们直接返回集合的大小。