当前位置: 首页>>代码示例 >>用法及示例精选 >>正文

Java ConcurrentSkipListSet用法及代码示例


ConcurrentSkipListSetJava 中的类是Java集合框架并实施采集接口和AbstractSet 类。它提供了可扩展的并发版本Java 中的NavigableSet。 ConcurrentSkipListSet的实现基于ConcurrentSkipListMap。 ConcurrentSkipListSet 中的元素默认按自然顺序或按Comparator Interface在设定的创建时间提供，具体取决于使用哪个构造函数。

由于它实现了排序集<E>和导航集<E>，它类似于TreeSet具有并发的附加函数。由于它是线程安全的，因此可以由多个线程同时使用，而 TreeSet 不是线程安全的。

类层次结构：

ConcurrentSkipListSet-in-Java

声明：

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

Where E is the type of elements maintained by this collection

ConcurrentSkipListSet 的一些要点：

  • 它实现了可串行化,可克隆,可迭代<E>,集合<E>,导航集<E>,设置<E>,SortedSet Interface接口。
  • 它不允许 null 元素，因为 null 参数和返回值无法可靠地区分元素是否缺失。
  • 它的实现提供了包含、添加和删除操作及其变体的平均 log(n) 时间成本。
  • 它是线程安全的。
  • 当需要并发修改集合时，它应该优先于实现Set接口。

构造函数：

1.ConcurrentSkipListSet()：该构造函数用于构造一个空集。

ConcurrentSkipListSet<E> set = new ConcurrentSkipListSet<E>();

2. ConcurrentSkipListSet(Collection<E> c)：该构造函数用于构造一个集合，并将 Collection 的元素作为参数传递。

ConcurrentSkipListSet<E> set = new ConcurrentSkipListSet<E>(Collection<E> c);

3. ConcurrentSkipListSet(Comparator<E> comparator)：此构造函数用于构造一个新的空集，该集根据指定的比较器对其元素进行排序。

ConcurrentSkipListSet<E> set = new ConcurrentSkipListSet<E>(Comparator<E> comparator);

4. ConcurrentSkipListSet(SortedSet<E> s)：该构造函数用于构造一个包含相同元素并使用与指定排序集相同的顺序的新集。

ConcurrentSkipListSet<E> set = new ConcurrentSkipListSet<E>(SortedSet<E> s);

示例 1：

Java 


// Java program to demonstrate ConcurrentSkipListSet 
  
import java.util.*; 
import java.util.concurrent.ConcurrentSkipListSet; 
  
class ConcurrentSkipListSetLastExample1 { 
    public static void main(String[] args) 
    { 
  
        // Initializing the set using 
        // ConcurrentSkipListSet() 
        ConcurrentSkipListSet<Integer> set 
            = new ConcurrentSkipListSet<Integer>(); 
  
        // Adding elements to this set 
        set.add(78); 
        set.add(64); 
        set.add(12); 
        set.add(45); 
        set.add(8); 
  
        // Printing the ConcurrentSkipListSet 
        System.out.println("ConcurrentSkipListSet: " + set); 
  
        // Initializing the set using 
        // ConcurrentSkipListSet(Collection) 
        ConcurrentSkipListSet<Integer> set1 
            = new ConcurrentSkipListSet<Integer>(set); 
  
        // Printing the ConcurrentSkipListSet1 
        System.out.println("ConcurrentSkipListSet1: "
                           + set1); 
  
        // Initializing the set using 
        // ConcurrentSkipListSet() 
        ConcurrentSkipListSet<String> set2 
            = new ConcurrentSkipListSet<>(); 
  
        // Adding elements to this set 
        set2.add("Apple"); 
        set2.add("Lemon"); 
        set2.add("Banana"); 
        set2.add("Apple"); 
  
        // creating an iterator 
        Iterator<String> itr = set2.iterator(); 
  
        System.out.print("Fruits Set: "); 
        while (itr.hasNext()) { 
            System.out.print(itr.next() + " "); 
        } 
    } 
}

输出：

ConcurrentSkipListSet: [8, 12, 45, 64, 78]
ConcurrentSkipListSet1: [8, 12, 45, 64, 78]
Fruits Set: Apple Banana Lemon


示例2：

Java 


// Java program to demonstrate ConcurrentSkipListSet 
  
import java.util.concurrent.ConcurrentSkipListSet; 
  
class ConcurrentSkipListSetLastExample1 { 
    
    public static void main(String[] args) 
    { 
  
        // Initializing the set using ConcurrentSkipListSet() 
        ConcurrentSkipListSet<Integer> 
            set = new ConcurrentSkipListSet<Integer>(); 
  
        // Adding elements to this set 
        // using add() method 
        set.add(78); 
        set.add(64); 
        set.add(12); 
        set.add(45); 
        set.add(8); 
  
        // Printing the ConcurrentSkipListSet 
        System.out.println("ConcurrentSkipListSet: "
                           + set); 
  
        // Printing the highest element of the set 
        // using last() method 
        System.out.println("The highest element of the set: "
                           + set.last()); 
  
        // Retrieving and removing first element of the set 
        System.out.println("The first element of the set: "
                           + set.pollFirst()); 
  
        // Checks if 9 is present in the set 
        // using contains() method 
        if (set.contains(9)) 
            System.out.println("9 is present in the set."); 
        else
            System.out.println("9 is not present in the set."); 
  
        // Printing the size of the set 
        // using size() method 
        System.out.println("Number of elements in the set = "
                           + set.size()); 
    } 
}

输出：

ConcurrentSkipListSet: [8, 12, 45, 64, 78]
The highest element of the set: 78
The first element of the set: 8
9 is not present in the set.
Number of elements in the set = 4

ConcurrentSkipListSet 的方法

METHOD

DESCRIPTION
ConcurrentSkipListSet add() 如果指定元素尚不存在，则将其添加到该集合中。
ConcurrentSkipListSet ceiling() 返回该集合中大于或等于给定元素的最小元素，如果不存在这样的元素则返回 null。
ConcurrentSkipListSet clear() 删除该集合中的所有元素。
ConcurrentSkipListSet clone() 返回此 ConcurrentSkipListSet 实例的浅拷贝。
ConcurrentSkipListSet comparator() 返回用于对该集合中的元素进行排序的比较器，如果该集合使用其元素的自然排序，则返回 null。
ConcurrentSkipListSet contains() 如果此集合包含指定元素，则返回 true。
ConcurrentSkipListSet descendingIterator() 按降序返回此集合中元素的迭代器。
ConcurrentSkipListSet descendingSet() 返回此集合中包含的元素的逆序视图。
ConcurrentSkipListSet equals() 比较指定对象与该集合是否相等。
ConcurrentSkipListSet first() 返回当前集合中的第一个(最低)元素。
ConcurrentSkipListSet floor() 返回该集合中小于或等于给定元素的最大元素，如果没有这样的元素，则返回 null。
ConcurrentSkipListSet headSet() 返回此集合中元素严格小于 toElement 的部分的视图。
ConcurrentSkipListSet headSet() 返回此集合中元素小于(或等于，如果包含为 true)toElement 的部分的视图。
ConcurrentSkipListSet higher() 返回此集合中严格大于给定元素的最小元素，如果不存在这样的元素，则返回 null。
ConcurrentSkipListSet isEmpty() 按升序返回此集合中元素的迭代器。
ConcurrentSkipListSet last() 返回当前集合中的最后一个(最高)元素。
ConcurrentSkipListSet lower() 返回该集合中严格小于给定元素的最大元素，如果不存在这样的元素，则返回 null。
ConcurrentSkipListSet pollFirst() 检索并删除第一个(最低)元素，如果该集合为空，则返回 null。
ConcurrentSkipListSet pollLast() 检索并删除最后一个(最高)元素，如果该集合为空，则返回 null。
ConcurrentSkipListSet remove() 从此集合中删除指定元素(如果存在)。
ConcurrentSkipListSet removeAll() 从此集合中删除指定集合中包含的所有元素。
ConcurrentSkipListSet size() 返回该集合中的元素数量。
ConcurrentSkipListSet spliterator() 返回该集合中元素的 Spliterator。

ConcurrentSkipListSet subSet()

ConcurrentSkipListSet subSet()

 返回此集合中元素范围从 fromElement 到 toElement 的部分的视图。
ConcurrentSkipListSet subSet() 返回此集合的部分视图，其元素范围从 fromElement(包括)到 toElement(不包括)。
ConcurrentSkipListSet tailSet() 返回此集合中元素大于或等于 fromElement 的部分的视图。
ConcurrentSkipListSet tailSet() 返回此集合中元素大于(或等于，如果包含为 true)fromElement 的部分的视图。

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

METHOD

DESCRIPTION
AbstractSet.hashCode() 返回该集合的哈希码值。

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

METHOD

DESCRIPTION
AbstractCollection addAll() 将指定集合中的所有元素添加到此集合中(可选操作)。
AbstractCollection containsAll() 如果此集合包含指定集合中的所有元素，则返回 true。
AbstractCollection retainAll() 仅保留此集合中包含在指定集合中的元素(可选操作)。
AbstractCollection toArray() 返回一个包含此集合中所有元素的数组。
AbstractCollection toArray() 返回一个包含该集合中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
AbstractCollection toString() 返回此集合的字符串表示形式。

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

METHOD

DESCRIPTION
Set addAll() 如果指定集合中的所有元素尚不存在，则将它们添加到该集合中(可选操作)。
Set containsAll() 如果此集合包含指定集合的所有元素，则返回 true。
Set hashCode() 返回该集合的哈希码值。
Set retainAll() 仅保留此集中包含在指定集合中的元素(可选操作)。
Set toArray() 返回一个包含该集合中所有元素的数组。
Set toArray() 返回一个包含该集合中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

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

METHOD

DESCRIPTION
parallelStream() 返回一个可能并行的 Stream 并以此集合作为其源。
removeIf(Predicate<? super E> 过滤器) 删除此集合中满足给定谓词的所有元素。
stream() 返回以此集合作为源的顺序 Stream。

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

METHOD

DESCRIPTION
Iterable forEach() 对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常。


相关用法


注：本文由纯净天空筛选整理自RishabhPrabhu大神的英文原创作品 ConcurrentSkipListSet in Java with Examples。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。