Java 中的 AbstractSet

2024年9月10日 | 阅读 17 分钟

在 Java 中，AbstractSet 类是 Java 集合框架的成员，并扩展了 AbstractCollection 类。它表示一个抽象集，它是一个无序的元素集合，没有重复值。集合是一种只允许元素出现一次的数据结构，这意味着如果一个元素被多次添加到集合中，它只会出现在集合中一次。

AbstractSet 类提供了 Set 接口的骨架实现，Set 接口是 Java 集合框架的成员，并指定了集合应实现的一组方法。Set 接口扩展了 Collection 接口，Collection 接口是 Java 集合框架的成员，并指定了集合应实现的一组方法。

AbstractSet 类是一个抽象类，这意味着它不能直接实例化。相反，它必须被子类化以创建具体集合。AbstractSet 类为 Set 接口中定义的许多方法提供了默认实现，例如 add()、contains() 和 remove()。这些方法是使用 iterator() 方法返回的迭代器实现的，iterator() 方法在 AbstractCollection 类中定义并由 AbstractSet 类实现。

使用 AbstractSet 类的主要优点之一是它提供了一种简单有效的方法来实现 Set 接口。通过子类化 AbstractSet 类，开发人员可以创建具体集合，而无需从头开始实现 Set 接口中定义的所有方法。

AbstractSet 类还提供了几种用于实现集合的有用方法。例如，size() 方法返回集合中的元素数量，isEmpty() 方法在集合为空时返回 true，clear() 方法从集合中删除所有元素。

AbstractSet 类还提供了几种用于搜索和操作集合中元素的方法。例如，contains() 方法在集合包含特定元素时返回 true，remove() 方法从集合中删除特定元素，toArray() 方法返回一个包含集合中所有元素的数组。

除了 AbstractSet 类提供的方法之外，Set 接口还定义了集合必须实现的其他几种方法。例如，addAll() 方法将元素集合添加到集合中，retainAll() 方法从集合中删除所有不在特定集合中的元素，removeAll() 方法从集合中删除所有在特定集合中的元素。

总的来说，AbstractSet 类是 Java 中实现集合的有用工具。它提供了一种简单有效的方法来实现 Set 接口，并提供了几种用于搜索和操作集合中元素的有用方法。通过子类化 AbstractSet 类，开发人员可以创建易于使用和维护的具体集合。

AbstractSet 类还提供了几种用于比较集合的方法。equals() 方法比较两个集合并在它们包含相同元素时返回 true，hashCode() 方法返回集合的哈希码值。

集合的一个重要方面是它们不允许重复值。这由 add() 方法强制执行，如果添加到集合中的元素已经存在于集合中，则该方法返回 false。contains() 方法可用于在尝试添加元素之前检查元素是否已存在于集合中。

集合通常与其他集合（例如列表和映射）结合使用。例如，两个集合的交集可以通过创建一个新集合并只添加两个集合中都存在的元素来计算。两个集合的并集可以通过创建一个新集合并添加两个集合中的所有元素来计算。

Java 集合框架中有几种具体的集合实现，例如 HashSet 和 TreeSet 类。HashSet 类使用哈希表实现集合，为添加、搜索和删除元素提供快速性能。TreeSet 类使用树数据结构实现集合，为按排序顺序搜索和遍历元素提供快速性能。

这是一个如何在 Java 中实现 AbstractSet 的示例

import java.util.AbstractSet;
import java.util.Iterator;

public abstract class MyAbstractSet<E> extends AbstractSet<E> {
    // Abstract method that must be implemented by concrete subclasses
    public abstract Iterator<E> iterator();

    // Concrete methods that can be used by subclasses
    @Override
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

    @Override
    public int size() {
        int size = 0;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            size++;
            it.next();
        }
        return size;
    }
}

此 AbstractSet 类提供了 Set 接口的骨架实现。它有一个抽象方法 iterator，必须由具体子类实现，以及两个具体方法 add 和 size，子类可以按原样使用它们，或在必要时覆盖它们。

要创建具体集合子类，您需要扩展此 AbstractSet 类并提供 iterator 方法的实现。例如

import java.util.Iterator;

public class MySet<E> extends MyAbstractSet<E> {
    private E[] elements;

    public MySet(E[] elements) {
        this.elements = elements;
    }

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

    private class MySetIterator implements Iterator<E> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < elements.length;
        }

        @Override
        public E next() {
            return elements[index++];
        }
    }
}

此 MySet 类是一个具体集合子类，它存储固定数组的元素并提供这些元素的迭代器。

以下是使用 Java 中的 AbstractSet 类（包括具体子类）的完整示例。

import java.util.AbstractSet;
import java.util.Iterator;

public class AbstractSetExample {
    public static void main(String[] args) {
        // Create a set of strings
        String[] elements = {"apple", "banana", "cherry"};
        MySet<String> set = new MySet<>(elements);

        // Iterate over the set and print the elements
        System.out.println("Elements in set: ");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        // Add a new element to the set
        set.add("dragonfruit");

        // Check the size of the set
        System.out.println("\nSize of set: " + set.size());
    }
}

// Abstract set class
abstract class MyAbstractSet<E> extends AbstractSet<E> {
    // Abstract method that must be implemented by concrete subclasses
    public abstract Iterator<E> iterator();

    // Concrete methods that can be used by subclasses
    @Override
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

    @Override
    public int size() {
        int size = 0;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            size++;
            it.next();
        }
        return size;
    }
}

// Concrete set subclass
class MySet<E> extends MyAbstractSet<E> {
    private E[] elements;

    public MySet(E[] elements) {
        this.elements = elements;
    }

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

    private class MySetIterator implements Iterator<E> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < elements.length;
        }

        @Override
        public E next() {
            return elements[index++];
        }
    }
}

当您运行此代码时，您应该看到以下输出

Elements in set: 
apple
banana
cherry

Size of set: 3

在此示例中，我们定义了一个名为 MyAbstractSet 的 AbstractSet 类，它提供了 Set 接口的骨架实现。它有一个抽象方法 iterator，必须由具体子类实现，以及两个具体方法 add 和 size，子类可以按原样使用它们，或在必要时覆盖它们。

我们还定义了一个名为 MySet 的具体集合子类，它存储固定数组的元素并提供这些元素的迭代器。MySet 类扩展了 MyAbstractSet 类并提供了 iterator 方法的实现。

在 AbstractSetExample 类的 main 方法中，我们创建了 MySet 类的一个实例并存储了一些元素。然后我们使用 iterator 方法迭代集合并打印元素。

接下来，我们尝试通过调用 add 方法向集合添加一个新元素，但 MySet 类不支持此操作，因为它未在 MyAbstractSet 类中实现。相反，add 方法抛出 UnsupportedOperationException。

最后，我们调用 size 方法获取集合的大小，并打印结果。

以下是完整的示例，附带一些额外的注释

import java.util.AbstractSet;
import java.util.Iterator;

public class AbstractSetExample {
    public static void main(String[] args) {
        // Create a set of strings
        String[] elements = {"apple", "banana", "cherry"};
        MySet<String> set = new MySet<>(elements);

        // Iterate over the set and print the elements
        System.out.println("Elements in set: ");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        // Try to add a new element to the set
        try {
            set.add("dragonfruit");
        } catch (UnsupportedOperationException e) {
            System.out.println("\nCannot add elements to this set");
        }

        // Check the size of the set
        System.out.println("\nSize of set: " + set.size());
    }
}

// Abstract set class
abstract class MyAbstractSet<E> extends AbstractSet<E> {
    // Abstract method that must be implemented by concrete subclasses
    public abstract Iterator<E> iterator();

    // Concrete methods that can be used by subclasses
    @Override
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

    @Override
    public int size() {
        int size = 0;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            size++;
            it.next();
        }
        return size;
    }
}

// Concrete set subclass
class MySet<E> extends MyAbstractSet<E> {
    private E[] elements;

    public MySet(E[] elements) {
        this.elements = elements;
    }

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

    private class MySetIterator implements Iterator<E> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < elements.length;
        }

        @Override
        public E next() {
            return elements[index++];
        }
    }
}

输出

Elements in set: 
apple
banana
cherry

Cannot add elements to this set

Size of set: 3

此输出显示 MySet 类正确地迭代集合中的元素并返回正确的大小，但它不支持 add 操作。

总而言之，AbstractSet 类是实现 Java 中 Set 接口的有用基类。它提供了 Set 接口的骨架实现，并允许您只定义与特定集合实现相关的方法。当您创建新的集合类时，这可以节省大量时间和精力，因为您不必担心从头开始实现 Set 接口的所有方法。

为了更好地理解 AbstractSet 类的工作原理以及如何在自己的代码中使用它，仔细研究它提供的方法和功能会很有帮助。

首先，AbstractSet 类扩展了 AbstractCollection 类，而 AbstractCollection 类本身是 Collection 接口的抽象实现。这意味着 AbstractSet 类提供了 Collection 接口和 Set 接口的骨架实现。

AbstractSet 类的一个关键特性是它提供了 iterator 方法的实现，该方法返回一个 Iterator 对象，可用于迭代集合中的元素。此 Iterator 对象由 AbstractSet 类的 iterator 方法创建，并由 AbstractSet 类用于实现其他几个方法，例如 size 和 contains。

AbstractSet 类还提供了 add 和 remove 方法的具体实现，允许您从集合中添加和删除元素。但是，这些方法默认会抛出 UnsupportedOperationException，因此如果您想支持这些操作，则需要在具体集合子类中覆盖它们。

AbstractSet 类的另一个有用功能是它提供了 equals 方法的实现，允许您比较两个集合是否相等。equals 方法比较两个集合中的元素，而不是集合对象本身，因此它可以用于确定两个集合是否包含相同的元素，无论它们如何实现。

最后，AbstractSet 类提供了许多其他方法和功能，在 Java 中使用集合时会很有用。其中包括用于检查集合大小、检查集合是否为空以及清除集合中所有元素的方法。它还提供了将另一个集合中的所有元素添加到集合中，以及从集合中删除所有也在另一个集合中的元素的方法。

要创建具体集合子类，只需扩展 AbstractSet 类并提供 iterator 方法的实现。如果需要为特定集合实现自定义其行为，还可以覆盖 AbstractSet 类的任何其他方法。

在上面的示例中，我们创建了一个名为 MySet 的集合类，它存储固定数组的元素并提供这些元素的迭代器。我们使用 AbstractSet 类作为基类，并实现了 iterator 方法来创建具体集合子类。

我们还在 AbstractSet 类中提供了 add 和 size 方法的具体实现，但这些方法在必要时可以由具体子类覆盖。在 MySet 类中，我们没有覆盖 add 方法，因此在调用时它会抛出 UnsupportedOperationException。

总之，AbstractSet 类是 Java 中创建自定义集合实现的有用工具，在代码中使用集合时可以节省大量时间和精力。

Java 中 AbstractSet 的优缺点

使用集合的主要优点之一是它们不允许重复值，这对于存储必须唯一的数据（例如用户帐户或产品代码）很有用。集合还可以用于通过将集合中的所有元素添加到集合中，然后从集合中检索元素来消除集合中的重复值。

集合的另一个优点是它们为搜索和操作元素提供了快速性能。对于使用哈希表实现的集合（例如 HashSet 类），contains() 和 remove() 方法的平均时间复杂度为 O(1)。对于使用哈希表实现的集合，add() 方法的平均时间复杂度为 O(1)，但在最坏情况下，如果哈希表需要调整大小，则时间复杂度可能为 O(n)。

TreeSet 类为按排序顺序搜索和遍历元素提供了快速性能，add()、remove() 和 contains() 方法的时间复杂度为 O(log n)。但是，由于维护树数据结构的开销，TreeSet 类在添加和删除元素方面的性能可能比 HashSet 类慢。

集合的主要缺点之一是它们无法以特定顺序访问元素。集合没有索引，并且元素不以特定顺序存储。如果您需要以特定顺序访问元素，可以使用不同的集合，例如列表或映射。

集合的另一个缺点是它们不允许您存储元素的多个出现。如果您需要存储元素的多个出现，可以使用不同的集合，例如列表或映射。

总之，AbstractSet 类是 Java 中实现集合的有用工具。它提供了一种简单有效的方法来实现 Set 接口，并提供了几种用于搜索和操作集合中元素的有用方法。集合对于存储必须唯一的数据很有用，并且它们为搜索和操作元素提供了快速性能。但是，它们不提供以特定顺序访问元素的任何方法，并且不允许您存储元素的多个出现。通过子类化 AbstractSet 类，开发人员可以创建易于使用和维护的具体集合。

一些重要点

集合的一个常见用例是消除集合中的重复值。例如，考虑一个包含多个电子邮件出现次数的电子邮件列表。要删除重复的电子邮件，可以创建一个集合并将列表中的所有电子邮件添加到集合中。集合将只允许每封电子邮件出现一次，因此结果集合将只包含唯一的电子邮件。

要从列表中删除重复的电子邮件，您可以创建一个新列表并将集合中的所有电子邮件添加到新列表中。新列表将只包含唯一的电子邮件，没有重复项。这是一个如何完成的示例

List<String> emails =...; // List of emails with duplicates
Set<String> emailSet = new HashSet<>(); // Set to store unique emails

// Add all of the emails from the list to the set
for (String email : emails) {
    emailSet.add(email);
}

// Create a new list and add all of the emails from the set
List<String> uniqueEmails = new ArrayList<>();
uniqueEmails.addAll(emailSet);

集合的另一个常见用例是检查集合是否包含特定元素。例如，考虑一个需要搜索特定用户的用户列表。要搜索列表，可以创建一个集合并将列表中的所有用户添加到集合中。集合将只允许每个用户出现一次，因此搜索集合将比搜索列表快得多。

要检查集合是否包含特定用户，可以使用 contains() 方法。如果集合包含该用户，则表示该用户存在于列表中。这是一个如何完成的示例

List<User> users =...; // List of users
Set<User> userSet = new HashSet<>(); // Set to store users

// Add all of the users from the list to the set
for (User user : users) {
    userSet.add(user);
}

User searchUser =...; // User to search for

if (userSet.contains(searchUser)) {
    // User is present in the list
} else {
    // User is not present in the list
}

集合还可以用于比较两个集合并确定两个集合中都存在的元素，或者一个集合中存在而另一个集合中不存在的元素。这可以使用 Set 接口提供的 intersection() 和 difference() 方法来完成。

要计算两个集合的交集，可以创建一个新集合并只添加两个集合中都存在的元素。要计算两个集合的差集，可以创建一个新集合并只添加一个集合中存在而另一个集合中不存在的元素。这是一个如何执行这些操作的示例

import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> set1 = new MySet(); // Set 1
        Set<String> set2 = new MySet(); // Set 2

        // Add elements to set 1 and set 2
        set1.add("a");
        set1.add("b");
        set1.add("c");
        set2.add("b");
        set2.add("c");
        set2.add("d");

        // Create a new set for the intersection and add the elements that are present in both sets
        Set<String> intersection = new MySet();
        for (String element : set1) {
            if (set2.contains(element)) {
                intersection.add(element);
            }
        }

        // Print the elements in the intersection set
        System.out.println("Intersection:");
        for (String element : intersection) {
            System.out.println(element);
        }
    }
}

输出

Intersection:
b
c

交集集合包含元素“b”和“c”，它们同时存在于集合 1 和集合 2 中。

请注意，AbstractSet 类使用 iterator() 方法和 contains() 方法提供了 intersection() 方法的默认实现，因此如果您要子类化 AbstractSet 类，则无需自己实现此操作。但是，默认实现可能不是计算两个集合交集的最有效方法，具体取决于应用程序的特定要求。

Set 接口定义了以下抽象方法，必须由具体集合实现

add(E e): 如果指定的元素尚不存在，则将其添加到集合中。如果元素已添加到集合中，则返回 true；如果元素已存在于集合中，则返回 false。
addAll(Collection c): 如果指定集合中的所有元素尚不存在，则将它们添加到集合中。如果已将任何元素添加到集合中，则返回 true；如果所有元素都已存在于集合中，则返回 false。
clear(): 从集合中删除所有元素。
contains(Object o): 如果集合包含指定元素，则返回 true；如果元素不存在于集合中，则返回 false。
containsAll(Collection c): 如果集合包含指定集合中的所有元素，则返回 true；如果任何元素不存在于集合中，则返回 false。
isEmpty(): 如果集合为空，则返回 true；如果集合包含任何元素，则返回 false。
iterator(): 返回一个 Iterator 对象，可用于迭代集合中的元素。
remove(Object o): 如果指定元素存在，则将其从集合中删除。如果元素已从集合中删除，则返回 true；如果元素不存在于集合中，则返回 false。
removeAll(Collection c): 如果指定集合中的所有元素存在，则将它们从集合中删除。如果已从集合中删除任何元素，则返回 true；如果所有元素都不存在于集合中，则返回 false。
retainAll(Collection c): 从集合中删除所有不包含在指定集合中的元素。如果已从集合中删除任何元素，则返回 true；如果所有元素都存在于集合中，则返回 false。
size(): 返回集合中的元素数量。

要继续子类化 AbstractSet 类以创建具体集合，您需要为 Set 接口定义的其余抽象方法提供实现。

这是一个如何实现 removeAll() 和 retainAll() 方法的示例

import java.util.AbstractSet;
import java.util.Set;
import java.util.Iterator;

public class MySet extends AbstractSet<String> implements Set<String> {
    
    // Array to store the elements in the set
    private String[] elements;
    
    public MySet() {
        // Initialize the array
        elements = new String[0];
    }
    
    // Add, addAll, and other methods as previously implemented...
    
    @Override
    public boolean removeAll(Collection<?> c) {
        // Remove the elements from the set
        boolean modified = false;
        for (Object o : c) {
            if (remove(o)) {
                modified = true;
            }
        }
        
        return modified;
    }
    
    @Override
    public boolean retainAll(Collection<?> c) {
        // Remove the elements that are not present in the collection
        boolean modified = false;
        for (int i = 0; i < elements.length; i++) {
            if (!c.contains(elements[i])) {
                elements = Arrays.copyOfRange(elements, 0, i) + Arrays.copyOfRange(elements, i + 1, elements.length - 1);
                modified = true;
            }
        }
        
        return modified;
    }
}

通过这些实现，MySet 类是一个功能齐全的具体集合，可以像 Java 中的任何其他集合一样使用。您可以通过创建一个集合并向其中添加一些元素，然后使用 removeAll() 和 retainAll() 方法修改集合来测试 MySet 类。

这是一个如何测试 MySet 类的示例

import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> set = new MySet(); // Set to store elements

        // Add some elements to the set
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");

        // Remove the elements "a" and "c" from the set
        set.removeAll(Arrays.asList("a", "c"));
        System.out.println("After removeAll(): " + set); // Output: [b, d]

        // Retain only the elements "b" and "d" in the set
        set.retainAll(Arrays.asList("b", "d"));
        System.out.println("After retainAll(): " + set); // Output: [b, d]
    }
}

输出

After removeAll(): [b, d]
After retainAll(): [b, d]

在使用 removeAll() 和 retainAll() 方法后，集合只包含元素“b”和“d”。

除了 Set 接口定义的抽象方法之外，AbstractSet 类还提供了几个在处理集合时有用的实用方法。这些实用方法包括

equals(Object o): 如果指定对象是一个集合且包含与当前集合相同的元素，则返回 true；如果对象不是集合或不包含相同的元素，则返回 false。
hashCode(): 返回集合的哈希码值。
toArray(): 返回一个包含集合中元素的数组。
toArray(T[] a): 返回一个包含集合中元素的数组，如果指定数组足够大以容纳元素，则使用该数组。

总之，AbstractSet 类是 Java 中实现 Set 接口的有用工具。它提供了 Set 接口的骨架实现，可以由具体集合子类扩展，并提供了许多有用的方法和功能，可以在代码中使用集合时节省时间和精力。AbstractSet 类是 Set 接口的抽象实现，它扩展了 AbstractCollection 类，而 AbstractCollection 类本身是 Collection 接口的抽象实现。它提供了 iterator 方法的实现，该方法返回一个 Iterator 对象，可用于迭代集合中的元素，以及 add 和 remove 方法的具体实现。它还提供了 equals 方法的实现，允许您比较两个集合是否相等，以及许多其他有用的方法和功能。总的来说，AbstractSet 类是 Java 中处理集合的强大而多功能的工具。

下一主题#

Java 中的 AbstractSet

Java 中 AbstractSet 的优缺点

一些重要点

Set 接口定义了以下抽象方法，必须由具体集合实现

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的 AbstractSet

Java 中 AbstractSet 的优缺点

一些重要点

Set 接口定义了以下抽象方法，必须由具体集合实现

相关帖子

Java 中使给定值达到最小硬币数

Java 中的 FloatBuffer duplicate() 方法及示例

How to Create Singleton Class in Java

Java 中的参数传递技术及示例

Cardinal Number in Java

Java 8 Stream API

Java 中的非原始数据类型

如何在 Java 中获取 UTC 时间

StrictMath scalb() Method in Java

Bouncy Number in Java

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器