ConcurrentSkipListSet in Java
ConcurrentSkipListSet is a class that is a part of collection framework in Java.It has been available since Java version 1.6.
ConcurrentSkipListSet is a scalable concurrent NavigableSet implementation based on a ConcurrentSkipListMap.The elements of the set are kept sorted according to their natural ordering, or by a Comparator provided at set creation time, depending on which constructor are used.
It provides a scalable and concurrent version of NavigableSet in Java.The ConcurrentSkipListSet is an asynchronous set.
The ConcurrentSkipListSet working is similar to NavigableSet.
Most of the methods used in ConcurrentSkipListSet have same methods as in Navigable Set.
Reason
The ConcurrentSkipListSet Implements Navigable Set Interface.
So, the ConcurrentSkipListSet contains all the properties of Navigable Set Interface.
The methods used in ConcurrentSkipListSet takes O(log n) in average case time complexity.These operations are executed safely and concurrently using multiple threads.
The name ConcurrentSkipListSet is assigned because the different methods execution is done concurrently.
Here object data type refers to Wrapper Class names to
- String
- Integer
- Float
- Byte
Different Methods used in ConcurrentSkipListSet
Method Name | Purpose |
add(value) | add is used to add elements to the created ConcurrentSkipListSet |
contains(value) | contains is used to check whether the prescribed element inside the parameter is present or not |
first() | first method prints the first value of the created ConcurrentSkipListSet |
last() | last method prints the last value of the created ConcurrentSkipListSet |
remove(value) | remove method used to remove the prescribed value from the created ConcurrentSkipListSet If the prescribed element is not present, then an error and false is returned If present true is returned |
pollFirst() | pollFirst method is used to remove the first element of the created ConcurrentSkipListSet |
pollLast() | pollFirst method is used to remove the last element of the created ConcurrentSkipListSet |
size() | size method is used to return the size of created ConcurrentSkipListSet. |
Creation of ConcurrentSkipListSet
Syntax
ConcurrentSkipListSet<data type of to be created object>Object Name=
ConcurrentSkipListSet<data type of to be created object>();
Java Program Rules
- The name of the program must same as the name of class with main method.
- All class, interface names must start with capital Letter.
- Every statement ends with a semi colon(;).
Example Program
File Name: ConCreate.java
// A program for ConcurrentSkipListSet creation
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConCreate{
public static void main(String[] args)
{
ConcurrentSkipListSet< String >con=new ConcurrentSkipListSet<String>();
System.out.println("ConcurrentSkipListSet is created: ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
}
}
Output:
ConcurrentSkipListSet is created:
ConcurrentSkipListSet is empty now: [ ]
add() Method
As the name suggests the add() method is used.This method helps us to insert the certain data type element into the created ConcurrentSkipListSet.
Syntax
Set object name.add(element to be added);
Let us explain this above method using an example program
Example Program
File Name: ConAdd.java
// A program for adding elements into the ConcurrentSkipListSet
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConAdd
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< String > con = new ConcurrentSkipListSet< String >();
System.out.println(“ConcurrentSkipListSet is created: ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add("Joe Root");
con.add("James Anderson");
con.add("Rahul Dravid");
con.add("Kumara Sangakkara");
con.add("Cheteshwar Pujara");
System.out.println(“ConcurrentSkipListSet: " + con);
}
}
Output
ConcurrentSkipListSet is created:
ConcurrentSkipListSet is empty now: [ ]
ConcurrentSkipListSet: [Cheteshwar Pujara, James Anderson, Joe Root, Kumara Sangakkara, Rahul Dravid]
Iteration
The elements in ConcurrentSkipListSet are usually stored in square brackets([ ]).
Iteration is the process of getting all the elements in a sequential manner.
There might be a case where there are huge numbers of elements stored in the ConcurrentSkipListSet. In this case we use iteration for finding the required element from the all set of elements.
This iteration method prevents manual searching of certain element from the created ConcurrentSkipListSet.
The majority of concurrent Collection implementations(including the majority of Queues) deviate from standard java.util practices in that their Iterators and Spliterators offer weakly consistent traversal rather than fast-fail traversal:
- They could go on while other operations are ongoing.
- They will never throw ConcurrentModificationException
- They are guaranteed to traverse each element exactly once as it was at the time of construction, and they may or may not reflect changes made afterward.
The iteration of Ascending order lists are faster than the descending order.
Reason
The reason for the above statement is that all ConcurrentSkipListSet are always sorted.
So, all the elements are stored in ascending order.
Because, the iteration is done straight from the beginning
In case of descending order lists the iterator has to move to the end and then perform iteration in reverse order.
The iteration can be done using:
- for each loop
- iterator
for each loop
It is special kind of loop used in Java. This loop does not require loop steps like initialization, condition, and updation.
This loop requires a loop variable and collection framework name.
Syntax
for(data type variable name : Collection Framework Name);
Example
for(int i : vector)
{
// block of statements
}
Example program
File Name: ConFor.java
// A program for iterating elements of ConcurrentSkipListSet using for each loop
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConFor
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Integer > con = new ConcurrentSkipListSet< Integer >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add(256000);
con.add(53410);
con.add(457820);
con.add(000004);
con.add(50104);
con.add(304884);
System.out.println(“ConcurrentSkipListSet: " + con);
System.out.println(“Iteration using for each loop");
for(int i : con)
{
System.out.println(“The ConcurrentSkipListSet element is: "+i);
}
}
}
Output
ConcurrentSkipListSet is created now
ConcurrentSkipListSet is empty now: [ ]
ConcurrentSkipListSet: [4, 50104, 53410, 256000, 304884, 457820]
Iteration using for each loop
The ConcurrentSkipListSet element is: 4
The ConcurrentSkipListSet element is: 50104
The ConcurrentSkipListSet element is: 53410
The ConcurrentSkipListSet element is: 256000
The ConcurrentSkipListSet element is: 304884
The ConcurrentSkipListSet element is: 457820
Iterator
The Iterator is an in-built method that is used as a substitute to for each loop. This iteration concept is always used for collection frameworks. This Iterator concept is always better for these types of heavy collection framework concepts. The Iterator is a class which is present in the java.util package. Iterator is a method present in the Iterator class.
Iteration Syntax
Iterator<data type of to be created object>Iterator object name =
Collection Framework Object Name.iterator();
Example Program
File Name: ConIt.java
// A program for iterating elements of ConcurrentSkipListSet using basic iterator concept
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConIt
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Integer > con = new ConcurrentSkipListSet< Integer >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add(256000);
con.add(53410);
con.add(457820);
con.add(000004);
con.add(50104);
con.add(304884);
System.out.println(“ConcurrentSkipListSet: " + con);
System.out.println(“Iteration using for iterator");
Iterator < Integer > Itrn = con.iterator();
while(Itrn.hasNext())
{
System.out.println(“The ConcurrentSkipListSet Elements are: "+Itrn.next());
}
}
}
Output
ConcurrentSkipListSet is created now
ConcurrentSkipListSet is empty now: [ ]
ConcurrentSkipListSet: [4, 50104, 53410, 256000, 304884, 457820]
Iteration using for iterator
The ConcurrentSkipListSet Elements are: 4
The ConcurrentSkipListSet Elements are: 50104
The ConcurrentSkipListSet Elements are: 53410
The ConcurrentSkipListSet Elements are: 256000
The ConcurrentSkipListSet Elements are: 304884
The ConcurrentSkipListSet Elements are: 457820
Reverse Order
The iteration done in the above process is in straight form. We also have the opportunity to iterate the elements of ConcurrentSkipListSet in reverse order too. But this process requires much time than the normal iteration.
Descending Iterator
The method which is used for iterating the elements in reverse manner or way is known as Descending Iterator. This descending Iterator is also the part of Iterator class.
Syntax
ConcurrentSkipListSet< The data type of prescribed object>Reverse order object name =
Collection Framework Object Name. descendingIterator();
Example Program
File Name: ConDesc.java
// A program for iterating elements of ConcurrentSkipListSet using basic descending iterator concept
// The iteration is done in reverse order
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConDesc
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Integer > con = new ConcurrentSkipListSet< Integer >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add(256000);
con.add(53410);
con.add(457820);
con.add(000004);
con.add(50104);
con.add(304884);
System.out.println(“The ConcurrentSkipListSet: " + con);
System.out.println(“Iteration using for descending iterator");
Iterator < Integer > Itrn = con.descendingIterator();
while(Itrn.hasNext())
{
System.out.println(“The ConcurrentSkipListSet Elements in reverse order are: " +Itrn.next());
}
}
}
Output
ConcurrentSkipListSet is created now
ConcurrentSkipListSet is empty now: [ ]
The ConcurrentSkipListSet: [4, 50104, 53410, 256000, 304884, 457820]
Iteration using for descending iterator
The ConcurrentSkipListSet Elements in reverse order are: 457820
The ConcurrentSkipListSet Elements in reverse order are: 304884
The ConcurrentSkipListSet Elements in reverse order are: 256000
The ConcurrentSkipListSet Elements in reverse order are: 53410
The ConcurrentSkipListSet Elements in reverse order are: 50104
The ConcurrentSkipListSet Elements in reverse order are: 4
Descending Set
This is also the other to get the ConcurrentSkipListSet elements in reverse order.The descendingSet is method of ConcurrentSkipListSet class.
The unique property of Descending Set is that the descendingSet returns NavigableSet collection framework values.
Syntax
NavigableSet<The data type of prescribed object>object name =
Collection Framework object name.descendingSet();
Example Program
File Name: ConDesc2.java
// A program for ConcurrentSkipListSet using descending Set concept
// The process creates a new Descending Set
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConDesc2
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Integer > con = new ConcurrentSkipListSet< Integer >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add(256000);
con.add(53410);
con.add(457820);
con.add(000004);
con.add(50104);
con.add(304884);
System.out.println(“The ConcurrentSkipListSet: " + con);
System.out.println(“Creation of new Descending Set which has the properties of Naivgable Set");
NavigableSet < Integer > NavSet = con.descendingSet();
System.out.println(“The Descending Set of ConcurrentSkipListSet is : " + NavSet);
}
}
Output
ConcurrentSkipListSet is created now
ConcurrentSkipListSet is empty now: [ ]
The ConcurrentSkipListSet: [4, 50104, 53410, 256000, 304884, 457820]
Creation of new Descending Set which has the properties of Navigable Set
The Descending Set of ConcurrentSkipListSet is: [457820, 304884, 256000, 53410, 50104, 4]
With the help of this created we can perform all the methods of Navigable Set.Let us understand with the help of an example.
Example Program
File Name: ConSet.java
// Explaining the properties of created Descending Set
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConSet
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Integer > con = new ConcurrentSkipListSet< Integer >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add(256000);
con.add(53410);
con.add(457820);
con.add(000004);
con.add(50104);
con.add(304884);
System.out.println(“The ConcurrentSkipListSet: " + con);
System.out.println(“Creation of new Descending Set which has the properties of Navigable Set");
NavigableSet < Integer > NavSet = con.descendingSet();
System.out.println(“The Descending Set of ConcurrentSkipListSet is : " + NavSet);
System.out.println(" _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \n");
NavSet.add(183);
NavSet.add(69);
System.out.println(“ The Created descending Set after adding the elements is:"+NavSet);
NavSet.remove(304884);
System.out.println(“ The Created descending Set after removing the elements is:"+NavSet);
System.out.println(“ The Created descending Set size is: "+NavSet.size());
}
}
Output:
ConcurrentSkipListSet is created now
ConcurrentSkipListSet is empty now: [ ]
The ConcurrentSkipListSet: [4, 50104, 53410, 256000, 304884, 457820]
Creation of new Descending set which has the properties of Navigable Set
The Descending Set of ConcurrentSkipListSet is: [457820, 304884, 256000, 53410, 50104, 4]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
The Created descending Set after adding the elements is:[457820, 304884, 256000, 53410, 50104, 183, 69, 4]
The Created descending Set after removing the elements is:[457820, 256000, 53410, 50104, 183, 69, 4]
The Created descending Set size is: 7
Deletion of Elements
The process of removing the elements of ConcurrentSkipListSet by using in built methods is known as deletion of elements.The in built methods used are:
- remove() method
- pollFirst() method
- pollLast() method
remove() method
This is an in built method of java.util package. This method is used for removing the certain elements from the created ConcurrentSkipListSet.
Syntax
ConcurrentSkipListSet object name.remove(element to be removed);
Note:
If the element prescribed is not present, then we are not going to face error in Java JDK compiler.
Example Program
File Name: ConRem.java
/* A program for removal of certain element from ConcurrentSkipListSet using remove() method */
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConRem
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Character > con = new ConcurrentSkipListSet< Character >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add('x');
con.add('5');
con.add('.');
con.add('p');
con.add('&');
con.add('/');
System.out.println(“The ConcurrentSkipListSet before removal: " + con);
con.remove('/');
System.out.println(“The ConcurrentSkipListSet after removal: " + con);
}
}
Output:
ConcurrentSkipListSet is created now
ConcurrentSkipListSet is empty now: [ ]
The ConcurrentSkipListSet before removal: [&, ., /, 5, p, x]
The ConcurrentSkipListSet before removal: [&, ., 5, p, x]
Note point Program
File Name: ConRem.java
// A program for removal of certain element from ConcurrentSkipListSet using remove() method
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConRem
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Character > con = new ConcurrentSkipListSet< Character >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add('x');
con.add('5');
con.add('.');
con.add('p');
con.add('&');
con.add('/');
System.out.println(“The ConcurrentSkipListSet before removal: " + con);
System.out.println(“ The Character ^ is not present in the ConcurrentSkipListSet ");
con.remove('^');
System.out.println(“The ConcurrentSkipListSet after removal: " + con);
}
}
Output
ConcurrentSkipListSet is created now
ConcurrentSkipListSet is empty now: [ ]
The ConcurrentSkipListSet before removal: [&, ., /, 5, p, x]
The Character ^ is not present in the ConcurrentSkipListSet
The ConcurrentSkipListSet after removal: [&, ., /, 5, p, x]
This output is based on Java JDK Compiler.The result may be different for other kind of compilers.
pollFirst() and pollLast() methods
They are also the in built methods.They are also used to remove the elements.
pollFirst() is used to remove the first element of the set or else returns null if the ConcurrentSkipListSet is empty.
pollLast() is used to remove the first element of the set or else returns null if the ConcurrentSkipListSet is empty.
Syntax
ConcurrentSkipListSet object name.pollFirst();
ConcurrentSkipListSet object name.pollLast();
Example Program
File Name: ConPoll.java
/* A program for removal of first or last elements from ConcurrentSkipListSet using some in built methods method */
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConPoll
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Character > con = new ConcurrentSkipListSet< Character >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add('x');
con.add('5');
con.add('.');
con.add('p');
con.add('&');
con.add('0');
con.add('1');
con.add('h');
con.add('k');
System.out.println(“The ConcurrentSkipListSet before removal: " + con);
con.pollFirst();
System.out.println(“The ConcurrentSkipListSet after removal: " + con);
con.pollLast();
System.out.println(“The ConcurrentSkipListSet after removal: " + con);
System.out.println(“The value of first element in ConcurrentSkipListSet which is to be removed is : " + con.pollFirst());
System.out.println(“The value of last element in ConcurrentSkipListSet which is to be removed is : " + con.pollLast());
System.out.println(“The ConcurrentSkipListSet after removal: " + con);
}
}
Output
ConcurrentSkipListSet is created now
ConcurrentSkipListSet is empty now: [ ]
The ConcurrentSkipListSet before removal: [&, ., 0, 1, 5, h, k, p, x]
The ConcurrentSkipListSet after removal: [., 0, 1, 5, h, k, p, x]
The ConcurrentSkipListSet after removal: [., 0, 1, 5, h, k, p]
The value of first element in ConcurrentSkipListSet which is to be removed is : .
The value of last element in ConcurrentSkipListSet which is to be removed is : p
The ConcurrentSkipListSet after removal: [0, 1, 5, h, k]
contains() Method
This is also one of the in-built method used for the ConcurrentSkipListSet.This method is used to get the result of the specified element present in the created ConcurrentSkipListSet.
Syntax
ConcurrentSkipListSet object name.contains(element to be searched);
Example Program
File Name: ConCon.java
// A program to whether a certain element is present or not using contains() method
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConCon
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Character > con = new ConcurrentSkipListSet< Character >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“ConcurrentSkipListSet is empty now: " + con);
con.add('x');
con.add('5');
con.add('.');
con.add('p');
con.add('&');
con.add('/');
System.out.println(“The element ' 5 ' is present is " + con.contains('5'));
System.out.println(“The element ' | ' is present is " + con.contains('|'));
}
}
Output
ConcurrentSkipListSet is created now
ConcurrentSkipListSet is empty now: [ ]
The element ' 5 ' is present is true
The element ' | ' is present is false
size() Method
This is also one of the in-built method present in the ConcurrentSkipListSet.This method is used to know the size of the created ConcurrentSkipListSet.
Syntax
ConcurrentSkipListSet object name.size();
Example Program
File Name: ConSize.java
// A program to know the size of the created ConcurrentSkipListSet
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConSize
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Character > con = new ConcurrentSkipListSet< Character >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“The size of ConcurrentSkipListSet is : " + con.size());
con.add('x');
con.add('5');
con.add('"');
System.out.println(“The size of ConcurrentSkipListSet is : " + con.size());
System.out.println(“The ConcurrentSkipListSet is : " + con);
con.add('p');
con.add('&');
con.add('/');
System.out.println(“The size of ConcurrentSkipListSet is : " + con.size());
System.out.println(“The ConcurrentSkipListSet is : " + con);
}
}
Output
ConcurrentSkipListSet is created now
The size of ConcurrentSkipListSet is: 0
The size of ConcurrentSkipListSet is: 3
The ConcurrentSkipListSet is: [", 5, x]
The size of ConcurrentSkipListSet is: 6
The ConcurrentSkipListSet is: [", &, /, 5, p, x]
Some other in built methods used for ConcurrentSkipListSet are
isEmpty() and clear Method
The isEmpty() method is used to find whether the created ConcurrentSkipListSet is empty or not.If empty the method return True and other cases returns False.
The clear() method is used to remove all the elements present in the created ConcurrentSkipListSet.
Example Program
File Name: ConMet.java
// A program to know usage of methods isEmpty and clear
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConMet
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Character > con = new ConcurrentSkipListSet< Character >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“The ConcurrentSkipListSet is empty : " + con.isEmpty());
con.add('x');
con.add('5');
con.add(' " ');
System.out.println(“The ConcurrentSkipListSet is empty : " + con.isEmpty());
con.add('p');
con.add('&');
con.add('/');
System.out.println(“The size of ConcurrentSkipListSet is : " + con.size());
System.out.println(“The ConcurrentSkipListSet is : " + con);
con.clear();
System.out.println(“The ConcurrentSkipListSet is empty : " + con.isEmpty());
System.out.println(“The size of ConcurrentSkipListSet is : " + con.size());
System.out.println(“The ConcurrentSkipListSet is : " + con);
}
}
Output
ConcurrentSkipListSet is created now
The ConcurrentSkipListSet is empty: true
The ConcurrentSkipListSet is empty: false
The size of ConcurrentSkipListSet is: 6
The ConcurrentSkipListSet is: [", &, /, 5, p, x]
The ConcurrentSkipListSet is empty: true
The size of ConcurrentSkipListSet is: 0
The ConcurrentSkipListSet is: [ ]
Creation of Subsets in ConcurrentSkipListSet
There are three types of Subsets which can be created using the created ConcurrentSkipListSet. All these Sub Sets are brought into the ConcurrentSkipListSet from the Navigable Set Interface. So, all the sub sets created have the properties of Navigable Set.
The three different Sub Sets are
- headSet()
- tailSet()
- subSet()
headSet()
This is one of the types of subset of ConcurrentSkipListSet. Head Set creates a new set which has values less than the prescribed element. If the Boolean expression is true then the specified element e will be present in the created Head Set.
Syntax
NavigableSet < data type of created object > object name =
ConcurrentSkipListSet Name.headSet(element e, Boolean value);
Example Program
File Name: ConHead.java
// A program to create a Head Set.
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConHead
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Integer > con = new ConcurrentSkipListSet< Integer >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“The ConcurrentSkipListSet is empty : " + con);
con.add(21);
con.add(22);
con.add(23);
con.add(24);
con.add(25);
con.add(26);
con.add(27);
con.add(28);
con.add(29);
con.add(30);
System.out.println(“The created ConcurrentSkipListSet is: " +con);
NavigableSet < Integer > head1 = con.headSet(23,false);
System.out.println(“The created Head Set 1 is: " +head1);
NavigableSet < Integer > head2 =con.headSet(26,true);
System.out.println(“The created Head Set 2 is: " +head2);
}
}
Output
ConcurrentSkipListSet is created now
The ConcurrentSkipListSet is empty: [ ]
The created ConcurrentSkipListSet is: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
The created Head Set 1 is: [21, 22]
The created Head Set 2 is: [21, 22, 23, 24, 25, 26]
tailSet()
This is also one of the sub set of ConcurrentSkipListSet. This is used to create a sub set which has elements which are greater than the specified element. If the Boolean expression is true then the specified element e will be present in the created Tail Set.
Syntax
NavigableSet < data type of created object > object name =
ConcurrentSkipListSet Name.tailSet(element e, Boolean value);
Example Program
File Name: ConTail.java
// A program to create a Tail Set.
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class ConTail
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Integer > con = new ConcurrentSkipListSet< Integer >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“The ConcurrentSkipListSet is empty : " + con);
con.add(21);
con.add(22);
con.add(23);
con.add(24);
con.add(25);
con.add(26);
con.add(27);
con.add(28);
con.add(29);
con.add(30);
System.out.println(“The created ConcurrentSkipListSet is: " +con);
NavigableSet < Integer > tail1 = con.tailSet(25,false);
System.out.println("The created Tail Set 1 is: " +tail1);
NavigableSet < Integer > tail2 = con.tailSet(28,true);
System.out.println("The created Tail Set 2 is: " +tail2);
}
}
Output
ConcurrentSkipListSet is created now
The ConcurrentSkipListSet is empty: [ ]
The created ConcurrentSkipListSet is: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
The created Tail Set 1 is: [26, 27, 28, 29, 30]
The created Tail Set 2 is: [28, 29, 30]
Sub Set
This is the last type of Sub Set which can be created for ConcurrentSkipListSet.This type of sub set has elements which are between the specified two elements e1, e2. If the Boolean expression is true then the specified elements e1, e2 will be present in the created Sub Set.
Syntax
NavigableSet < data type of created object > object name =
ConcurrentSkipListSet Name.subSet
(element e1, Boolean value1, element e1, Boolean value);
Example Program
File Name: ConSub.java
// A program to create a Sub Set.
import java.util.*;
import java.util.concurrent.ConcurrentSkipListSet;
class Main
{
public static void main(String[ ] args)
{
ConcurrentSkipListSet< Integer > con = new ConcurrentSkipListSet< Integer >();
System.out.println(“ConcurrentSkipListSet is created now ");
System.out.println(“The ConcurrentSkipListSet is empty : " + con);
con.add(21);
con.add(22);
con.add(23);
con.add(24);
con.add(25);
con.add(26);
con.add(27);
con.add(28);
con.add(29);
con.add(30);
System.out.println(“The created ConcurrentSkipListSet is: " +con);
NavigableSet < Integer > sub1 = con.subSet(25, false, 29, true);
System.out.println("The created Sub Set 1 is: " +sub1);
NavigableSet < Integer > sub2 = con.subSet(28, true, 30, true);
System.out.println(“The created Sub Set 2 is: " +sub2);
}
}
Output
ConcurrentSkipListSet is created now
The ConcurrentSkipListSet is empty: [ ]
The created ConcurrentSkipListSet is: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
The created Sub Set 1 is: [26, 27, 28, 29]
The created Sub Set 2 is: [28, 29, 30]