Java 中的 ConcurrentSkipListSet

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

Java 的 ConcurrentSkipListSet 类是 Java 集合框架的一部分，它实现了 Collection 接口和 AbstractSet 类。它提供了 Java 中 NavigableSet 的并发、可伸缩版本。ConcurrentSkipListSet 在其实现中基于 ConcurrentSkipListMap。根据使用哪个构造函数，ConcurrentSkipListSet 中的条目将按其自然顺序默认排序，或按在集合构造时指定的 Comparator 排序。

它与 TreeSet 相当，因为它实现了 SortedSet 和 NavigableSet，但它还具有并发的特性。与非线程安全的 TreeSet 相比，它可以被多个线程并发使用。

声明

public class ConcurrentSkipListSet<E>
    extends AbstractSet<E>
        implements NavigableSet<E>, Cloneable, Serializable

Where E is the type of elements maintained by this collection

关于 ConcurrentSkipListSet 的重要注意事项

ConcurrentSkipListSet 是 Java 中 Set 接口的线程安全实现。这意味着可以在不要求显式同步的情况下，由多个线程并发地访问和修改该集合。
ConcurrentSkipListSet 以排序顺序存储元素，可以使用 Comparator 对象进行自定义。维护一个排序的数据集合是此方法的一个常见用例。
ConcurrentSkipListSet 允许 null 元素，但由于 null 元素不可比较，因此在初始化集合时使用非 null Comparator 很重要。
ConcurrentSkipListSet 提供了执行添加和删除元素、检查元素是否在集合中、以及检索集合中的第一个或最后一个元素等操作的方法。
ConcurrentSkipListSet 是 java.util.concurrent 包的一部分，该包提供了用于 Java 并发编程的线程安全数据结构和实用程序的集合。

构造函数

ConcurrentSkipListSet 提供了几种可以用来创建类新实例的构造函数。以下是 Java 8 中可用的构造函数：

ConcurrentSkipListSet(): 创建一个空的 ConcurrentSkipListSet，其元素按自然顺序排序。

文件名: ConcurrentSkipListSetExample.java

import java.util.concurrent.ConcurrentSkipListSet;

public class ConcurrentSkipListSetExample {

  public static void main(String[] args) {

    // Create a ConcurrentSkipListSet
    ConcurrentSkipListSet<String> set = new ConcurrentSkipListSet<>();

    // Add some elements to the set
    set.add("apple");
    set.add("banana");
    set.add("orange");

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

    // Remove an element from the set
    set.remove("banana");

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

    // Check if an element exists in the set
    System.out.println("Does the set contain 'apple'? " + set.contains("apple"));
    System.out.println("Does the set contain 'banana'? " + set.contains("banana"));

    // Get the first and last elements in the set
    System.out.println("First element in the set: " + set.first());
    System.out.println("Last element in the set: " + set.last());
  }
}

输出

Elements in the set:applebanana
orange
Updated elements in the set:
apple
orange
Does the set contain 'apple'? true
Does the set contain 'banana'? false
First element in the set: apple
Last element in the set: orange

ConcurrentSkipListSet(Comparator<? super E> comparator): 创建一个空的 ConcurrentSkipListSet，其元素按指定的 Comparator 对象排序。

文件名: ConcurrentSkipListSetComparatorExample.java

import java.util.Comparator;
import java.util.concurrent.ConcurrentSkipListSet;

public class ConcurrentSkipListSetComparatorExample {

  public static void main(String[] args) {

    // Create a Comparator to sort elements in descending order
    Comparator<String> descendingOrder = new Comparator<String>() {
      @Override
      public int compare(String o1, String o2) {
        return o2.compareTo(o1);
      }
    };

    // Create a ConcurrentSkipListSet with the Comparator
    ConcurrentSkipListSet<String> set = new ConcurrentSkipListSet<>(descendingOrder);

    // Add some elements to the set
    set.add("apple");
    set.add("banana");
    set.add("orange");

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

输出

Elements in the set (in descending order):
orange
banana
apple

ConcurrentSkipListSet(Collection<? extends E> c): 创建一个包含指定集合元素的新的 ConcurrentSkipListSet，并按自然顺序排序。

文件名: ConcurrentSkipListSetCollectionExample.java

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ConcurrentSkipListSet;

public class ConcurrentSkipListSetCollectionExample {

  public static void main(String[] args) {

    // Create a List of elements
    List<String> list = new ArrayList<>();
    list.add("apple");
    list.add("banana");
    list.add("orange");
    list.add("pear");
    list.add("peach");

    // Sort the elements in ascending order
    list.sort(null);

    // Create a ConcurrentSkipListSet with the Collection
    ConcurrentSkipListSet<String> set = new ConcurrentSkipListSet<>(list);

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

    // Create a Comparator to sort elements in descending order
    Comparator<String> descendingOrder = new Comparator<String>() {
      @Override
      public int compare(String o1, String o2) {
        return o2.compareTo(o1);
      }
    };

    // Create another ConcurrentSkipListSet with the Collection and the Comparator
    ConcurrentSkipListSet<String> descendingSet = new ConcurrentSkipListSet<>(descendingOrder);
    descendingSet.addAll(list);

    // Print the elements in the descending set (in descending order)
    System.out.println("Elements in the descending set (in descending order):");
    Iterator<String> descendingIterator = descendingSet.descendingIterator();
    while (descendingIterator.hasNext()) {
      System.out.println(descendingIterator.next());
    }

    // Add some elements to the set
    set.add("grape");
    set.add("kiwi");

    // Create a new set that contains only the elements that are in the first set but not in the descending set
    ConcurrentSkipListSet<String> differenceSet = new ConcurrentSkipListSet<>(set);
    differenceSet.removeAll(descendingSet);

    // Print the elements in the difference set (in ascending order)
    System.out.println("Elements in the difference set (in ascending order):");
    for (String element : differenceSet) {
      System.out.println(element);
    }

    // Clear the sets
    set.clear();
    descendingSet.clear();
    differenceSet.clear();
  }
}

输出

Elements in the set (in ascending order):
apple
banana
orange
peach
pear
Elements in the descending set (in descending order):
apple
banana
orange
peach
pear
Elements in the difference set (in ascending order):
grape
kiwi

ConcurrentSkipListSet(SortedSet<E> s): 创建一个包含与指定 SortedSet 对象相同元素并按相同顺序排序的新 ConcurrentSkipListSet。

文件名: ConcurrentSkipListSetSortedSetExample.java

import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentSkipListSet;

public class ConcurrentSkipListSetSortedSetExample {

    public static void main(String[] args) {

        // Create a SortedSet of integers
        SortedSet<Integer> sortedSet = new TreeSet<>();
        sortedSet.add(3);
        sortedSet.add(1);
        sortedSet.add(4);
        sortedSet.add(1);
        sortedSet.add(5);

        // Create a ConcurrentSkipListSet from the SortedSet
        ConcurrentSkipListSet<Integer> set = new ConcurrentSkipListSet<>(sortedSet);

        // Print the elements in the set
        System.out.println("Elements in the set:");
        for (Integer element : set) {
            System.out.println(element);
        }

        // Remove an element from the set
        set.remove(3);

        // Print the updated elements in the set
        System.out.println("Updated elements in the set:");
        for (Integer element : set) {
            System.out.println(element);
        }

        // Check if an element exists in the set
        System.out.println("Does the set contain 1? " + set.contains(1));
        System.out.println("Does the set contain 3? " + set.contains(3));

        // Get the first and last elements in the set
        System.out.println("First element in the set: " + set.first());
        System.out.println("Last element in the set: " + set.last());

        // Create a new SortedSet of integers
        SortedSet<Integer> sortedSet2 = new TreeSet<>();
        sortedSet2.add(2);
        sortedSet2.add(4);
        sortedSet2.add(6);

        // Add the elements from the second SortedSet to the set
        set.addAll(sortedSet2);

        // Print the updated elements in the set
        System.out.println("Updated elements in the set:");
        for (Integer element : set) {
            System.out.println(element);
        }

        // Get a sub-set of elements in the set
        SortedSet<Integer> subSet = set.subSet(2, 5);
        System.out.println("Elements in the sub-set:");
        for (Integer element : subSet) {
            System.out.println(element);
        }

    }
}

输出

Elements in the set:1
3
4
5
Updated elements in the set:
1
4
5
Does the set contain 1? true
Does the set contain 3? falseFirst element in the set: 1Last element in the set: 5
Updated elements in the set:1
2
4
5
6
Elements in the sub-set:
2
4

示例 1

文件名: ConcurrentSkipListSetDemo.java

// Import the required package
import java.util.concurrent.ConcurrentSkipListSet;

public class ConcurrentSkipListSetDemo {
    public static void main(String[] args) {
        // Create a new ConcurrentSkipListSet with some elements
        ConcurrentSkipListSet<String> set = new ConcurrentSkipListSet<>();
        set.add("dog");
        set.add("cat");
        set.add("bird");
        set.add("fish");
        
        // Print the contents of the set
        System.out.println("Initial set: " + set);
        
        // Add another element to the set
        set.add("zebra");
        
        // Print the contents of the set again
        System.out.println("Set after adding 'zebra': " + set);
        
        // Remove an element from the set
        set.remove("cat");
        
        // Print the contents of the set again
        System.out.println("Set after removing 'cat': " + set);
    }
}

输出

Initial set: [bird, cat, dog, fish]
Set after adding 'zebra': [bird, cat, dog, fish, zebra]
Set after removing 'cat': [bird, dog, fish, zebra]

示例 2

文件名: ConcurrentSkipListSetExample2.java

// Import the required package
import java.util.concurrent.ConcurrentSkipListSet;
// Define a class to demonstrate the usage of ConcurrentSkipListSet
public class ConcurrentSkipListSetExample {
    public static void main(String[] args) {
        // Create a new ConcurrentSkipListSet with some elements
        ConcurrentSkipListSet<Integer> set = new ConcurrentSkipListSet<>();
        set.add(5);
        set.add(3);
        set.add(7);
        set.add(1);
        
        // Print the contents of the set
        System.out.println("Initial set: " + set);
        
        // Get the first and last elements of the set
        int first = set.first();
        int last = set.last();
        
        // Print the first and last elements
        System.out.println("First element: " + first);
        System.out.println("Last element: " + last);
        
        // Create a new set and add some elements to it
        ConcurrentSkipListSet<Integer> otherSet = new ConcurrentSkipListSet<>();
        otherSet.add(4);
        otherSet.add(2);
        otherSet.add(6);
        
        // Add the elements of the other set to the original set
        set.addAll(otherSet);
        
        // Print the contents of the set again
        System.out.println("Set after adding other set: " + set);
        
        // Remove the first and last elements from the set
        set.remove(first);
        set.remove(last);
        
        // Print the contents of the set again
        System.out.println("Set after removing first and last: " + set);
    }
}

输出

Initial set: [1, 3, 5, 7]
First element: 1
Last element: 7
Set after adding other set: [1, 2, 3, 4, 5, 6, 7]
Set after removing first and last: [2, 3, 4, 5, 6]

ConcurrentSkipListSet 的方法

方法	描述
add(E e)	如果指定的元素尚不存在，则将其插入此集合。
addAll(Collection<? extends E> c)	将指定集合中的所有元素添加到此集合中，前提是它们尚不存在。
ceiling(E e)	ConcurrentSkipListSet 的 ceiling(E e) 方法返回此集合中小于或等于给定元素 e 的最小元素，如果不存在这样的元素，则返回 null。
clear()	ConcurrentSkipListSet 的 clear() 方法会移除集合中的所有元素。在此方法调用后，集合将为空。该操作是原子地执行的。
comparator()	ConcurrentSkipListSet 的 comparator() 方法返回用于对此集合中的元素进行排序的比较器，如果使用元素的自然排序，则返回 null。
contains(Object o)	ConcurrentSkipListSet 的 contains(Object o) 方法如果此集合包含指定的元素，则返回 true，否则返回 false。更正式地说，当且仅当此集合包含一个元素 e，使得 (o==null ? e==null : o.equals(e)) 时，它才返回 true。
descendingIterator()	ConcurrentSkipListSet 的 descendingIterator() 方法返回一个迭代器，用于按反向顺序遍历集合中的元素。
descendingSet()	ConcurrentSkipListSet 的 descendingSet() 方法返回集合中元素的反向视图。
first()	返回此集合中当前存在的第一个（最小）元素。
floor(E e)	返回此集合中小于或等于给定元素的最大元素，如果不存在这样的元素，则返回 null。
headSet(E toElement)	返回此集合中小于 toElement 的元素部分的视图。
headSet(E toElement, boolean inclusive)	ConcurrentSkipListSet 的 headSet(E toElement, boolean inclusive) 方法返回此集合中小于 toElement 的元素部分的视图。如果 inclusive 参数为 true，则返回的集合也包括 toElement。此方法提供了原始集合的新视图，而不会修改原始集合。
higher(E e)	返回此集合中小于给定元素的最大元素，如果不存在这样的元素，则返回 null。
isEmpty()	如果此集合不包含任何元素，则返回 true。
iterator()	返回一个迭代器，用于按升序遍历此集合中的元素。
last()	返回此集合中当前存在的最后一个（最大）元素。
lower(E e)	返回此集合中小于给定元素的最大元素，如果不存在这样的元素，则返回 null。
pollFirst()	检索并删除第一个（最小）元素，如果此集合为空，则返回 null。
pollLast()	检索并删除最后一个（最大）元素，如果此集合为空，则返回 null。
remove(Object o)	如果指定的元素存在，则将其从此集合中移除。
size()	返回此集合中的元素数量。
subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)	返回此集合中范围从 fromElement 到 toElement 的元素部分的视图。
subSet(E fromElement, E toElement)	返回此集合中范围从 fromElement（包含）到 toElement（不包含）的元素部分的视图。
tailSet(E fromElement)	返回此集合中大于或等于 fromElement 的元素部分的视图。
tailSet(E fromElement, boolean inclusive)	返回此集合中大于（或等于，如果 inclusive 为 true）fromElement 的元素部分的视图。

从 java.util.AbstractSet 类继承的方法

方法	描述
hashCode()	返回此集合的哈希码值。集合的哈希码定义为集合中元素哈希码的总和。null 元素不计入哈希码。为了与 Java 集合框架的互操作性，提供了此方法。

从 java.util.AbstractCollection 类继承的方法

方法	描述
addAll(Collection<? extends E> c)	AbstractCollection 类的 addAll(Collection<? extends E> c) 方法将指定集合中的所有元素添加到此集合中，前提是它们尚不存在。此操作的执行不是强制性的，并且其可用性不能保证在 AbstractCollection 接口的所有实现中都可用。
containsAll(Collection<?> c)	AbstractCollection 类的 containsAll(Collection<?> c) 方法返回一个布尔值，指示此集合是否包含指定集合中的所有元素。
retainAll(Collection<?> c)	AbstractCollection 的 retainAll(Collection<?> c) 方法会从集合中移除所有元素，除了那些包含在指定集合中的元素。换句话说，它只保留两个集合中都存在的元素。AbstractCollection 的实现可能不保证此方法的执行，因为这是一个可选操作。如果操作导致集合被修改，则方法返回 true，否则返回 false。
toArray()	Collection 接口的 toArray() 方法返回一个数组，该数组包含集合中的所有元素，顺序与集合迭代器返回的顺序相同。返回的数组的长度将等于集合的大小。如果集合为空，则该方法返回一个空数组。
toArray(T[] a)	Collection 接口的 toArray(T[] a) 方法返回一个包含此集合中所有元素的数组。如果指定的数组足够大以容纳所有元素，则使用指定的数组，否则，会为此目的分配一个具有相同运行时类型的数组。
toString()	AbstractCollection 的 toString() 方法返回集合的字符串表示形式。字符串表示形式由方括号（[]）括起来的集合元素列表组成。相邻元素由“,”（逗号和空格）分隔。

从 java.util.Set 接口继承的方法

方法	描述
addAll(Collection<? extends E> c)	ConcurrentSkipListSet 的 addAll(Collection<? extends E> c) 方法将指定集合中的所有元素添加到集合中，前提是它们尚不存在。不保证所有 ConcurrentSkipListSet 实现都会执行此方法，并且它被视为一个可选操作。
containsAll(Collection<?> c)	ConcurrentSkipListSet 的 containsAll(Collection<?> c) 方法检查指定集合中的所有元素是否都存在于集合中。如果所有元素都存在，则返回 true；否则返回 false。元素使用它们的自然顺序或在创建 ConcurrentSkipListSet 实例时传入的比较器提供的顺序进行比较。
hashCode()	ConcurrentSkipListSet 的 hashCode() 方法返回该集合的哈希码值。集合的哈希码定义为其元素的哈希码之和。根据 equals() 方法相等的两个集合应返回相同的哈希码值。空集合的哈希码值定义为零。
retainAll(Collection<?> c)	ConcurrentSkipListSet 的 retainAll(Collection<?> c) 方法仅保留集合中也包含在指定集合中的元素。换句话说，它从集合中移除所有不存在于指定集合中的元素。这是一个可选操作。
toArray()	ConcurrentSkipListSet 的 toArray() 方法返回一个数组，其中包含集合中的所有元素，顺序与它们在集合中出现的顺序相同。返回的数组是 Object 数组，其运行时类型未指定。
toArray(T[] a)	ConcurrentSkipListSet 的 toArray(T[] a) 方法返回一个包含该集合中所有元素的数组。返回数组的运行时类型是指定数组的运行时类型。如果集合适合指定的数组，则会在此数组中返回。否则，会分配一个具有指定数组运行时类型和此集合大小的新数组。

从 java.util.Collection 接口继承的方法

方法	描述
parallelStream()	parallelStream() 方法以该集合作为源，返回一个可能并行的流。parallelStream() 方法是 Collection 接口的一部分，它允许对集合中的元素进行并行处理。
removeIf(Predicate<? super E> filter)	Collection 接口的 removeIf(Predicate<? super E> filter) 方法会移除集合中满足给定谓词的所有元素。如果移除了任何元素，则返回 true，否则返回 false。如果指定的谓词为 null，则该方法将抛出 NullPointerException。
stream()	Collection 接口的 stream() 方法以该集合为源，返回一个顺序流。流元素的顺序由集合的迭代顺序决定。

从 java.lang.Iterable 接口继承的方法

方法	描述
forEach	forEach 方法继承自 Iterable 接口，它将给定的操作应用于集合中的每个元素，并按遇到的顺序执行。操作将为每个元素执行，直到所有元素都已处理完毕或操作抛出异常。

下一个主题Java 中的 Fail Fast 与 Fail-Safe

Java 中的 ConcurrentSkipListSet

声明

关于 ConcurrentSkipListSet 的重要注意事项

构造函数

示例 1

示例 2

ConcurrentSkipListSet 的方法

从 java.util.AbstractSet 类继承的方法

从 java.util.AbstractCollection 类继承的方法

从 java.util.Set 接口继承的方法

从 java.util.Collection 接口继承的方法

从 java.lang.Iterable 接口继承的方法

联系信息

关注我们

教程

面试题

在线编译器

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 中的 ConcurrentSkipListSet

声明

关于 ConcurrentSkipListSet 的重要注意事项

构造函数

示例 1

示例 2

ConcurrentSkipListSet 的方法

从 java.util.AbstractSet 类继承的方法

从 java.util.AbstractCollection 类继承的方法

从 java.util.Set 接口继承的方法

从 java.util.Collection 接口继承的方法

从 java.lang.Iterable 接口继承的方法

相关帖子

Java DRY 原则

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

Java 中将 Set 转换为 List

Java 中的平方数组数量

Java Obfuscator

如何在 Java 中查找 int 的大小

CompletableFuture in Java

在 Java 中反转二叉树

Java 中的无效操作数类型错误

Java 中的组合设计模式

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器