Java TreeSet Special Methods - GeeksforGeeks

25 Jan, 2022
TreeSet is one of the most important implementations of the SortedSet interface in Java that uses a Tree for storage. The TreeSet implements a NavigableSet interface by inheriting AbstractSet class. This means that the elements stored in a TreeSet are in an ordered way, i.e. in the ascending order. Because of this feature of TreeSet, it provides certain amazing methods of NavigableSet interface apart from those traditionally provided by the Collection interface.
Note: Since TreeSet is the implementation of Set, therefore it does not allow duplication of elements.
Some of specific methods provided by TreeSet are as follows:
floor() Methodlower() Methodceiling() Methodhigher() MethodsubSet() MethodheadSet() MethodtailSet() Method
floor() Method
lower() Method
ceiling() Method
higher() Method
subSet() Method
headSet() Method
tailSet() Method
Now let us discuss all methods along with their implementation which is as follows
Method 1: floor() Method
This method returns the greatest element in the set less than or equal to the given element, or null if there is no such element.
Arguments: A number less than or equal value needs to be searched for
Syntax:
treeSetObject.floor(argument) ;
Example:
Java
// Java Program to demonstrate Floor Method in TreeSet // Importing input output classesimport java.io.*;// Importing TreeSet and Set classes from java.util packageimport java.util.Set;import java.util.TreeSet; // Main classpublic class GFG {     // Main driver method    public static void main(String[] args)    {         // Creating an object of TreeSet of Integer type        // Initializing object with integer values using        // Set.of() method        TreeSet<Integer> treeSet            = new TreeSet<>(Set.of(12, 98, 54, 37, 68));         // Print and display elements in object        System.out.println("Tree set = " + treeSet);         // Case 1         // Using floor() method over treeSet elements but        // note floor() method is inclusive of the limit        // Hence maximum element is returned        System.out.println("floor(60) = "                           + treeSet.floor(60));         // Case 2         // Using floor() method over treeSet elements,        // therefore output of the below line will be the        // number itself        System.out.println("floor(54) = "                           + treeSet.floor(54));    }}
Tree set = [12, 37, 54, 68, 98]
floor(60) = 54
floor(54) = 54
Method 2: lower() Method
This method returns the greatest element in this set strictly less than the given element, or null if there is no such element.
Argument: Number whose less than value needs to be found.
Syntax: 
treeSetObject.lower(argument) ;
Example:
Java
// Java Program to demonstrate Lower Method in TreeSet // Importing input output classesimport java.io.*;// Importing TreeSet and Set classes from java.util packageimport java.util.Set;import java.util.TreeSet; // Main classclass GFG {     // Main driver method    public static void main(String[] args)    {         // Creating an object of TreeSet of Integer type        // Initializing object with integer values using        // Set.of() method        TreeSet<Integer> treeSet            = new TreeSet<>(Set.of(12, 98, 54, 37, 68));         // Print and display elements in object        System.out.println(treeSet);         // Case 1        // Using lower() method ober treeSet elements where        // argument passed is greater then max element in        // TreeSet therefore returning max element itself        System.out.println("lower(90) = "                           + treeSet.lower(90));         // Case 2        // Using lower() method ober treeSet elements where        // argument passed is not greater then max element        // in TreeSet therefore returning element lesser        // than that passed as an argument        System.out.println("lower(68) = "                           + treeSet.lower(68));         // Also note that lower() method is exclusive of the        // limit    }}
[12, 37, 54, 68, 98]
lower(90) = 68
lower(68) = 54
Method 3: ceiling() Method
This method returns the least element in this set greater than or equal to the given element, or null if there is no such element.
Argument: Number whose less than or equal value needs to be found.
Syntax: 
treeSetObject.lower(argument) ;
Example:
Java
// Java Program to demonstrate Ceiling Method in TreeSet// Importing input output classesimport java.io.*;// Importing TreeSet and Set classes from java.util packageimport java.util.Set;import java.util.TreeSet; // Main classclass GFG {     // Main driver method    public static void main(String[] args)    {         // Creating an object of TreeSet of Integer type        // Initializing object with integer values using        // Set.of() method        TreeSet<Integer> treeSet            = new TreeSet<>(Set.of(12, 98, 54, 37, 68));         // Print and display elements in object        System.out.println("tree set = " + treeSet);         // Using ceiling() method.        System.out.println("ceiling(50) = "                           + treeSet.ceiling(50));         // Note that ceiling method is inclusive of the        // limit. Therefore,output of the below line will be        // the same number.        System.out.println("ceiling(68) = "                           + treeSet.ceiling(68));         // Verification for null        System.out.println("ceiling(100) = "                           + treeSet.ceiling(100));    }}
tree set = [12, 37, 54, 68, 98]
ceiling(50) = 54
ceiling(68) = 68
ceiling(100) = null
Method 4: higher() Method  
This method returns the least element in this set strictly greater than the given element, or null if there is no such element.
Argument: The number whose less than value needs to be found.
Syntax:
treeSetObject.lower(argument) ;
Example:
Java
// Java Program to demonstrate Higher Method of TreeSet // Importing input output classesimport java.io.*;// Importing Set snd TreeSet classes from java.util packageimport java.util.Set;import java.util.TreeSet; // Main classclass GFG {     // Main driver method    public static void main(String[] args)    {         // Creating an object of TreeSet of Integer type        // Initializing object with integer values using        // Set.of() method        TreeSet<Integer> treeSet            = new TreeSet<>(Set.of(12, 98, 54, 37, 68));         // Print and display elements in object        System.out.println("tree set = " + treeSet);         // Using higher() method         // Case 1        System.out.println("higher(50) = "                           + treeSet.higher(50));         // Case 2        // Note that higher method is exclusive of the limit        // causing        //  output be the number greater than the number        //  passed        System.out.println("higher(68) = "                           + treeSet.higher(68));         // Case 3        // Verification for null        System.out.println("higher(98) = "                           + treeSet.higher(100));    }}
tree set = [12, 37, 54, 68, 98]
higher(50) = 54
higher(68) = 98
higher(98) = null
Method 5: subSet() Method
This method will return elements ranging from ‘fromElement‘ to ‘toElement‘.
Note: ‘fromElement’ is inclusive and ‘toElement’ is exclusive.
Syntax:
treeSetObject.subSet(fromElement, toElement);
// where fromElement is the lower limit (inclusive) and 
// toElement is the upper limit (exclusive) 
// of the set containing values between these limits
Example:
Java
// Java Program to demonstrate subset Method in TreeSet // Importing input output classesimport java.io.*;// Importing Set snd TreeSet classes from java.util packageimport java.util.Set;import java.util.TreeSet; // Main classclass GFG {     // Main driver method    public static void main(String[] args)    {         // Creating an object of TreeSet of Integer type        // Initializing object with integer values using        // Set.of() method        TreeSet<Integer> treeSet            = new TreeSet<>(Set.of(12, 98, 54, 37, 68));         // Print and display elements in object        System.out.println("tree set = " + treeSet);         // Using subSet() method         // Case 1        System.out.println(            "Elements between 54 and 98 are : "            + treeSet.subSet(54, 98));         // Case 2        // If we want to incude the upper limit        System.out.println(            "Elements between 54 and 98 including both the limits : "            + treeSet.subSet(54, true, 98, true));         // Case 3        // If we want to exclude the lower limit        System.out.println(            "Elements between 54 (exclusive) and 98 (inclusive) : "            + treeSet.subSet(54, false, 98, true));         // Case 4        // If we want to exclude both the limits        System.out.println(            "Elements between 54 (exclusive) and 98 (exclusive) : "            + treeSet.subSet(54, false, 98, false));    }}
tree set = [12, 37, 54, 68, 98]
Elements between 54 and 98 are : [54, 68]
Elements between 54 and 98 including both the limits : [54, 68, 98]
Elements between 54 (exclusive) and 98 (inclusive) : [68, 98]
Elements between 54 (exclusive) and 98 (exclusive) : [68]
Method 6: headSet() Method
This method will return elements of TreeSet which are less than the specified element.
Syntax:
treeSetObject.headSet(upToNumber) ;
Note: ‘upToNumber‘ is the upper limit of the numbers to be found (exclusive)
Example:
Java
// Java Program to demonstrate headSet Method in TreeSet // Importing input output classesimport java.io.*;// Importing Set snd TreeSet classes from java.util packageimport java.util.Set;import java.util.TreeSet; // Main classclass GFG {     // Main driver method    public static void main(String[] args)    {         // Creating an object of TreeSet of Integer type        // Initializing object with integer values using        // Set.of() method        TreeSet<Integer> treeSet            = new TreeSet<>(Set.of(12, 98, 54, 37, 68));         // Print and display elements in object        System.out.println("tree set = " + treeSet);         // Implementing headSet() method via TreeSet object         // Case 1        System.out.println("Elements upto 90 : "                           + treeSet.headSet(90));         // Case 2        // The function limit is exclusive of the argument        // passed        System.out.println("Elements upto 68 : "                           + treeSet.headSet(68));         // Case 3        // If we want to include the number passed, then        System.out.println("Elements upto 68 (inclusive) : "                           + treeSet.headSet(68, true));    }}
tree set = [12, 37, 54, 68, 98]
Elements upto 90 : [12, 37, 54, 68]
Elements upto 68 : [12, 37, 54]
Elements upto 68 (inclusive) : [12, 37, 54, 68]
Method 7: 
This method will return elements of TreeSet which are greater than or equal to the specified element. 
Syntax:
treeSetObject.tailSet(aboveThisNumber) ;
Note: ‘aboveThisNumber’ is the lower limit of the numbers to be found (inclusive).
Example:
Java
// Java Program to demonstrate tailSet Method in TreeSet // Importing input output classesimport java.io.*;import java.util.Set;import java.util.TreeSet; // Main classclass GFG {     // Main driver method    public static void main(String[] args)    {         // Creating an object of TreeSet of Integer type        // Initializing object with integer values using        // Set.of() method        TreeSet<Integer> treeSet            = new TreeSet<>(Set.of(12, 98, 54, 37, 68));         // Print and display elements in object        System.out.println("tree set = " + treeSet);         // Implementing tailSet()         // Case 1        System.out.println("Elements above 50 : "                           + treeSet.tailSet(50));         // Case 2        // The function limit is inclusive of the argument        // passed        System.out.println("Elements above 54 : "                           + treeSet.tailSet(54));         // Case 3        // If we want to exclude the number passed        System.out.println(            "Elements above 54 (exclusive) : "            + treeSet.tailSet(54, false));    }}
tree set = [12, 37, 54, 68, 98]
Elements above 50 : [54, 68, 98]
Elements above 54 : [54, 68, 98]
Elements above 54 (exclusive) : [68, 98]
sooda367
anikaseth98
sagar0719kumar
sumitgumber28
Java-Collections
java-treeset
Java
Java
Java-Collections
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stream In Java
Constructors in Java
Exceptions in Java
Functional Interfaces in Java
Different ways of Reading a text file in Java
Generics in Java
Introduction to Java
Comparator Interface in Java with Examples
Internal Working of HashMap in Java
Strings in Java