Course Curriculum

ConcurrentSkipListSet in Java with Examples

ConcurrentSkipListSet in Java with Examples

The ConcurrentSkipListSet class in Java is a part of the Java Collection Framework and implements the Collection interface and the AbstractSet class. It provides a scalable and concurrent version of NavigableSet in Java. The implementation of ConcurrentSkipListSet is based on ConcurrentSkipListMap. The elements in ConcurrentSkipListSet are sorted by default in their natural ordering or by a Comparator provided at set creation time, depending on which constructor is used.

Since it implements SortedSet<E> and NavigableSet<E>, it is similar to TreeSet with an added feature of being concurrent. Since it is a thread-safe, it can be used by multiple threads concurrently whereas TreeSet is not thread-safe.

Class Hierarchy:

ConcurrentSkipListSet-in-Java

Declaration:

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

Where E is the type of elements maintained by this collection

Some important points on ConcurrentSkipListSet:

  • It implements Serializable, Cloneable, Iterable<E>, Collection<E>, NavigableSet<E>, Set<E>, SortedSet<E> interfaces.
  • It does not allow null elements, because null arguments and return values cannot be reliably distinguished from the absence of elements.
  • Its implementation provides average log(n) time cost for contains, add, and remove operations and their variants.
  • It is thread-safe.
  • It should be preferred over implementing Set interface when concurrent modification of set is required.

Constructors:

1. ConcurrentSkipListSet(): This constructor is used to construct an empty set.

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

2. ConcurrentSkipListSet(Collection<E> c): This constructor is used to construct a set with the elements of the Collection passed as the parameter.

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

3. ConcurrentSkipListSet(Comparator<E> comparator): This constructor is used to construct a new, empty set that orders its elements according to the specified comparator.

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

4. ConcurrentSkipListSet(SortedSet<E> s): This constructor is used to construct a new set containing the same elements and using the same ordering as the specified sorted set.

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

Example 1:

// 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(55);
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() + " ");
}
}
}
result:

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

Example 2:

// 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(55);
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());
}
}
result:

ConcurrentSkipListSet: [8, 12, 55, 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

Methods of ConcurrentSkipListSet

  • add(E e) Adds the specified element to this set if it is not already present.
  • ceiling(E e) Returns the least element in this set greater than or equal to the given element, or null if there is no such element.
  • clear() Removes all of the elements from this set.
  • clone() Returns a shallow copy of this ConcurrentSkipListSet instance.
  • comparator() Returns the comparator used to order the elements in this set, or null if this set uses the natural ordering of its elements.
  • contains(Object o) Returns true if this set contains the specified element.
  • descendingIterator() Returns an iterator over the elements in this set in descending order.
  • descendingSet() Returns a reverse order view of the elements contained in this set.
  • equals(Object o) Compares the specified object with this set for equality.
  • first() Returns the first (lowest) element currently in this set.
  • floor(E e) Returns the greatest element in this set less than or equal to the given element, or null if there is no such element.
  • headSet(E toElement) Returns a view of the portion of this set whose elements are strictly less than toElement.
  • headSet(E toElement, boolean inclusive) Returns a view of the portion of this set whose elements are less than (or equal to, if inclusive is true) toElement.
  • higher(E e) Returns the least element in this set strictly greater than the given element, or null if there is no such element.
  • isEmpty() Returns an iterator over the elements in this set in ascending order.
  • last() Returns the last (highest) element currently in this set.
  • lower(E e) Returns the greatest element in this set strictly less than the given element, or null if there is no such element.
  • pollFirst() Retrieves and removes the first (lowest) element, or returns null if this set is empty.
  • pollLast() Retrieves and removes the last (highest) element, or returns null if this set is empty.
  • remove(Object o) Removes the specified element from this set if it is present.
  • removeAll(Collection<?> c) Removes from this set all of its elements that are contained in the specified collection.
  • size() Returns the number of elements in this set.
  • spliterator() Returns a Spliterator over the elements in this set.
    subSet(E fromElement, boolean

fromInclusive, E toElement, boolean toInclusive)

  • Returns a view of the portion of this set whose elements range from fromElement to toElement.
  • subSet(E fromElement, E toElement) Returns a view of the portion of this set whose elements range from
  • fromElement, inclusive, to toElement, exclusive.
  • tailSet(E fromElement) Returns a view of the portion of this set whose elements are greater than or equal to fromElement.
  • tailSet(E fromElement, boolean inclusive) Returns a view of the portion of this set whose elements are greater than (or equal to, if inclusive is true) fromElement.

Methods inherited from class java.util.AbstractSet

  • hashCode() Returns the hash code value for this set.

Methods inherited from class java.util.AbstractCollection

  • addAll(Collection<? extends E> c) Adds all of the elements in the specified collection to this collection (optional operation).
  • containsAll(Collection<?> c) Returns true if this collection contains all of the elements in the specified collection.
  • retainAll(Collection<?> c) Retains only the elements in this collection that are contained in the specified collection (optional operation).
  • toArray() Returns an array containing all of the elements in this collection.
  • toArray(T[] a) Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.
  • toString() Returns a string representation of this collection.

Methods inherited from interface java.util.Set

  • addAll(Collection<? extends E> c) Adds all of the elements in the specified collection to this set if they’re not already present (optional operation).
  • containsAll(Collection<?> c) Returns true if this set contains all of the elements of the specified collection.
    hashCode() Returns the hash code value for this set.
  • retainAll(Collection<?> c) Retains only the elements in this set that are contained in the specified collection (optional operation).
  • toArray() Returns an array containing all of the elements in this set.
  • toArray(T[] a) Returns an array containing all of the elements in this set; the runtime type of the returned array is that of the specified array.

Methods inherited from interface java.util.Collection

  • parallelStream() Returns a possibly parallel Stream with this collection as its source.
  • removeIf(Predicate<? super E> filter) Removes all of the elements of this collection that satisfy the given predicate.
  • stream() Returns a sequential Stream with this collection as its source.

Methods inherited from interface java.lang.Iterable

  • forEach(Consumer<? super T> action) Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception.
(Next Lesson) How to start learning Java