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]