Java TreeSet Class

Last Updated : 13 Feb 2026

Java TreeSet class implements the Set interface that uses a tree for storage. It inherits AbstractSet class and implements the NavigableSet interface. The objects of the TreeSet class are stored in ascending order.

The important points about the Java TreeSet class are:

Java TreeSet class contains unique elements only like HashSet.
Java TreeSet class access and retrieval times are quite fast.
Java TreeSet class doesn't allow null elements.
Java TreeSet class is non-synchronized.
Java TreeSet class maintains ascending order.
The TreeSet can only allow those generic types that are comparable. For example, the Comparable interface is being implemented by the StringBuffer class.

Internal Working of The TreeSet Class

TreeSet is being implemented using a binary search tree, which is self-balancing just like a Red-Black Tree. Therefore, operations such as a search, remove, and add consume O(log(N)) time. The reason behind this is there in the self-balancing tree. It is there to ensure that the tree height never exceeds O(log(N)) for all of the mentioned operations. Therefore, it is one of the efficient data structures in order to keep the large data that is sorted and also to do operations on it.

Key Aspects of TreeSet's Functionality

Red-Black Tree Structure: Each node in this tree is assigned a color-either red or black-which plays a crucial role in maintaining the tree's balance. This strategic coloring helps prevent the tree from becoming lopsided, which enhances performance and ensures that operations are processed quickly and efficiently.
Dynamic Rebalancing: Whenever elements are added or removed, TreeSet dynamically adjusts its internal structure. It ensures that the set's elements are always in ascending order, making it highly reliable for applications that require well-ordered data.
Handling Duplicates: TreeSet is designed to store only unique elements. Attempts to add duplicates are gracefully handled by the set, ensuring that only distinct elements are maintained. It is crucial for data integrity and simplifies management of collections where uniqueness is a priority.
Order Determination: The sorting of elements within TreeSet can follow the natural ordering of the elements or be defined by a custom comparator. This flexibility allows developers to control how elements are compared and ordered within the set.

Synchronization of The TreeSet Class

As already mentioned above, the TreeSet class is not synchronized. It means, if more than one thread concurrently accesses a tree set, and one of them accessing thread to modify it, then the synchronization must be done manually. It is usually done by doing some object synchronization techniques that encapsulates the set. However, in the case where no such object is found, then the set must be wrapped with the help of the Collections.synchronizedSet() method. It is advised to use the method during creation time in order to avoid the unsynchronized access of the set. The following code snippet shows the same.

Synchronization of The TreeSet Class

As already mentioned above, the TreeSet class is not synchronized. It means if more than one thread concurrently accesses a tree set, and one of the accessing threads modify it, then the synchronization must be done manually. It is usually done by doing some object synchronization that encapsulates the set. However, in the case where no such object is found, then the set must be wrapped with the help of the Collections.synchronizedSet() method. It is advised to use the method during creation time in order to avoid the unsynchronized access of the set. The following code snippet shows the same.

TreeSet treeSet = new TreeSet(); 
Set syncrSet = Collections.synchronziedSet(treeSet);

Hierarchy of theTreeSet Class

As shown in the above diagram, the Java TreeSet class implements the NavigableSet interface. The NavigableSet interface extends SortedSet, Set, Collection and Iterable interfaces in hierarchical order.

The TreeSet class in Java is a crucial part of the Java Collections Framework, designed to store elements in a sorted and unique manner, ensuring no duplicates. Here are the key points about its hierarchical structure:

SortedSet Interface: TreeSet directly implements the SortedSet interface, which extends the basic Set interface. This interface introduces methods for operations that maintain an order among the elements and support range-view functionalities, essential for ordered data manipulation.

NavigableSet Interface: Positioned below the SortedSet, the NavigableSet interface adds advanced navigation capabilities. It allows TreeSet to retrieve elements based on their precise relation to others in the set, enhancing its functionality for efficient data querying and manipulation.

Efficiency: Backed by a TreeMap using a red-black tree structure, TreeSet performs fundamental operations like adding, removing, and checking the presence of elements with logarithmic time complexity, making it ideal for high-performance applications that require quick data processing.

TreeSet Class Declaration

Let's see the declaration for java.util.TreeSet class.

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

Components of the Declaration

TreeSet<E> Class: The TreeSet class is declared as public, meaning it can be accessed from anywhere class within any package.
The <E> denotes that TreeSet is a generic class, capable of storing objects of any type, as specified by the user.
AbstractSet<E>: TreeSet class extends the AbstractSet interface that provides a skeletal implementation of the Set interface. It means that the TreeSet class inherits all the abstract methods from the AbstractSet interface.
NavigableSet<E>: By implementing NavigableSet, TreeSet gains() methods to navigate the set in relation to a given target element, such as higher, lower, ceiling, and floor. The interface extends SortedSet, which in turn extends Set, ensuring that TreeSet has all functionalities of a sorted and navigable set.
Cloneable: It indicates that TreeSet supports cloning, allowing it to be copied safely without affecting the original set.
Serializable: It ensures that a TreeSet can be serialized, meaning its state can be converted into a byte stream that can be reverted back into a copy of the TreeSet. Serialization is essential for saving the state of an object for later retrieval or transmission to a different processing environment.

Constructors of Java TreeSet Class

Constructor	Description
TreeSet()	It is used to construct an empty tree set that will be sorted in ascending order according to the natural order of the tree set.
TreeSet(Collection<? extends E> c)	It is used to build a new tree set that contains the elements of the collection c.
TreeSet(Comparator<? super E> comparator)	It is used to construct an empty tree set that will be sorted according to given comparator.
TreeSet(SortedSet<E> s)	It is used to build a TreeSet that contains the elements of the given SortedSet.

Methods of Java TreeSet Class

Method	Description
boolean add(E e)	It is used to add the specified element to this set if it is not already present.
boolean addAll(Collection<? extends E> c)	It is used to add all of the elements in the specified collection to this set.
E ceiling(E e)	It returns the equal or closest greatest element of the specified element from the set, or null there is no such element.
Comparator<? super E> comparator()	It returns a comparator that arranges elements in order.
IteratordescendingIterator()	It is used to iterate the elements in descending order.
NavigableSetdescendingSet()	It returns the elements in reverse order.
E floor(E e)	It returns the equal or closest least element of the specified element from the set, or null there is no such element.
SortedSetheadSet(E toElement)	It returns the group of elements that are less than the specified element.
NavigableSetheadSet(E toElement, boolean inclusive)	It returns the group of elements that are less than or equal to (if, inclusive is true) the specified element.
E higher(E e)	It returns the closest greatest element of the specified element from the set, or null there is no such element.
Iteratoriterator()	It is used to iterate the elements in ascending order.
E lower(E e)	It returns the closest least element of the specified element from the set, or null there is no such element.
E pollFirst()	It is used to retrieve and remove the lowest(first) element.
E pollLast()	It is used to retrieve and remove the highest(last) element.
Spliteratorspliterator()	It is used to create a late-binding and fail-fast spliterator over the elements.
NavigableSetsubSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)	It returns a set of elements that lie between the given range.
SortedSetsubSet(E fromElement, E toElement))	It returns a set of elements that lie between the given range which includes fromElement and excludes toElement.
SortedSettailSet(E fromElement)	It returns a set of elements that are greater than or equal to the specified element.
NavigableSettailSet(E fromElement, boolean inclusive)	It returns a set of elements that are greater than or equal to (if, inclusive is true) the specified element.
boolean contains(Object o)	It returns true if this set contains the specified element.
boolean isEmpty()	It returns true if this set contains no elements.
boolean remove(Object o)	It is used to remove the specified element from this set if it is present.
void clear()	It is used to remove all of the elements from this set.
Object clone()	It returns a shallow copy of this TreeSet instance.
E first()	It returns the first (lowest) element currently in this sorted set.
E last()	It returns the last (highest) element currently in this sorted set.
int size()	It returns the number of elements in this set.

Java TreeSet Examples

Java TreeSet Example 1:

Let's see a simple example of Java TreeSet.

FileName: TreeSet1.java

import java.util.*;
class TreeSet1{
 public static void main(String args[]){
  //Creating and adding elements
  TreeSet<String> al=new TreeSet<String>();
  al.add("Ravi");
  al.add("Vijay");
  al.add("Ravi");
  al.add("Ajay");
  //Traversing elements
  Iterator<String> itr=al.iterator();
  while(itr.hasNext()){
   System.out.println(itr.next());
  }
 }
}

Output:

Ajay
Ravi
Vijay

Java TreeSet Example 2:

Let's see an example of traversing elements in descending order.

FileName: TreeSet2.java

import java.util.*;
class TreeSet2{
 public static void main(String args[]){
 TreeSet<String> set=new TreeSet<String>();
		 set.add("Ravi");
		 set.add("Vijay");
		 set.add("Ajay");
		 System.out.println("Traversing element through Iterator in descending order");
		 Iterator i=set.descendingIterator();
		 while(i.hasNext())
		 {
			 System.out.println(i.next());
		 }
		 
 }
}

Output:

Traversing element through Iterator in descending order
Vijay
Ravi
Ajay
Traversing element through NavigableSet in descending order
Vijay
Ravi
Ajay

Java TreeSet Example 3:

Let's see an example to retrieve and remove the highest and lowest Value.

FileName: TreeSet3.java

import java.util.*;  
class TreeSet3{  
 public static void main(String args[]){  
 TreeSet<Integer> set=new TreeSet<Integer>();  
         set.add(24);  
         set.add(66);  
         set.add(12);  
         set.add(15);  
         System.out.println("Lowest Value: "+set.pollFirst());  
         System.out.println("Highest Value: "+set.pollLast());  
 }  
}  

Output:

Lowest Value: 12
Highest Value: 66

Java TreeSet Example 4:

In this example, we perform various NavigableSet operations.

FileName: TreeSet4.java

import java.util.*;
class TreeSet4{
 public static void main(String args[]){
  TreeSet<String> set=new TreeSet<String>();
		 set.add("A");
		 set.add("B");
		 set.add("C");
		 set.add("D");
		 set.add("E");
		 System.out.println("Initial Set: "+set);
		 
		 System.out.println("Reverse Set: "+set.descendingSet());
         
		 System.out.println("Head Set: "+set.headSet("C", true));
		
		 System.out.println("SubSet: "+set.subSet("A", false, "E", true));
		 
		 System.out.println("TailSet: "+set.tailSet("C", false));
 }
}

Output:

Initial Set: [A, B, C, D, E]
Reverse Set: [E, D, C, B, A]
Head Set: [A, B, C]
SubSet: [B, C, D, E]
TailSet: [D, E]

Java TreeSet Example 5:

In this example, we perform various SortedSetSet operations.

FileName: TreeSet5.java

import java.util.*;
class TreeSet5{
 public static void main(String args[]){
  TreeSet<String> set=new TreeSet<String>();
		 set.add("A");
		 set.add("B");
		 set.add("C");
		 set.add("D");
		 set.add("E");
		 
		 System.out.println("Intial Set: "+set);
		 
		 System.out.println("Head Set: "+set.headSet("C"));
		
		 System.out.println("SubSet: "+set.subSet("A", "E"));
		 
		 System.out.println("TailSet: "+set.tailSet("C"));
 }
}

Output:

Intial Set: [A, B, C, D, E]
Head Set: [A, B]
SubSet: [A, B, C, D]
TailSet: [C, D, E]

Java TreeSet Example: Book

Let's see a TreeSet example where we are adding books to the set and printing all the books. The elements in TreeSet must be of a Comparable type. String and Wrapper classes are Comparable by default. To add user-defined objects in TreeSet, you need to implement the Comparable interface.

FileName: TreeSetExample.java

import java.util.*;  
class Book implements Comparable<Book>{  
int id;  
String name,author,publisher;  
int quantity;  
public Book(int id, String name, String author, String publisher, int quantity) {  
    this.id = id;  
    this.name = name;  
    this.author = author;  
    this.publisher = publisher;  
    this.quantity = quantity;  
}  
// implementing the abstract method
public int compareTo(Book b) {  
    if(id>b.id){  
        return 1;  
    }else if(id<b.id){  
        return -1;  
    }else{  
    return 0;  
    }  
}  
}  
public class TreeSetExample {  
public static void main(String[] args) {  
    Set<Book> set=new TreeSet<Book>();  
    //Creating Books  
    Book b1=new Book(121,"Let us C","Yashwant Kanetkar","BPB",8);  
    Book b2=new Book(233,"Operating System","Galvin","Wiley",6);  
    Book b3=new Book(101,"Data Communications & Networking","Forouzan","Mc Graw Hill",4);  
    //Adding Books to TreeSet  
    set.add(b1);  
    set.add(b2);  
    set.add(b3);  
    //Traversing TreeSet  
    for(Book b:set){  
    System.out.println(b.id+" "+b.name+" "+b.author+" "+b.publisher+" "+b.quantity);  
    }  
}  
}  

Output:

101 Data Communications & Networking Forouzan Mc Graw Hill 4
121 Let us C Yashwant Kanetkar BPB 8
233 Operating System Galvin Wiley 6

ClassCast Exception in TreeSet

If we add an object of the class that is not implementing the Comparable interface, the ClassCast Exception is raised. Observe the following program.

FileName: ClassCastExceptionTreeSet.java

// important import statement
import java.util.*;

class Employee
{
    
int empId;
String name;

// getting the name of the employee
String getName()
{
    return this.name;
}

// setting the name of the employee
void setName(String name)
{
this.name = name;
}

// setting the employee id 
// of the employee
void setId(int a)
{
this.empId = a;
}

// retrieving the employee id of
// the employee
int getId()
{
return this.empId;
}

}

public class ClassCastExceptionTreeSet
{

// main method
public static void main(String[] argvs)
{
// creating objects of the class Employee
Employee obj1 = new Employee();

Employee obj2 = new Employee();

TreeSet<Employee> ts =  new TreeSet<Employee>();

// adding the employee objects to 
// the TreeSet class
ts.add(obj1);
ts.add(obj2);

System.out.println("The program has been executed successfully.");

}
}

Output:

Exception in thread "main" java.lang.ClassCastException: class Employee cannot be cast to class java.lang.Comparable (Employee is in unnamed module of loader 'app'; java.lang.Comparable is in module java.base of loader 'bootstrap')
	at java.base/java.util.TreeMap.compare(TreeMap.java:1569)
	at java.base/java.util.TreeMap.addEntryToEmptyMap(TreeMap.java:776)
	at java.base/java.util.TreeMap.put(TreeMap.java:785)
	at java.base/java.util.TreeMap.put(TreeMap.java:534)
	at java.base/java.util.TreeSet.add(TreeSet.java:255)
	at ClassCastExceptionTreeSet.main(ClassCastExceptionTreeSet.java:52)

Explanation: In the above program, it is required to implement a Comparable interface. It is because the TreeSet maintains the sorting order, and for doing the sorting the comparison of different objects that are being inserted in the TreeSet is must, which is accomplished by implementing the Comparable interface.

TreeSet Vs. HashSet

Feature	TreeSet	HashSet
Underlying Data Structure	Red-Black Tree	Hash Table
Ordering of Elements	Keeps elements sorted, which facilitates ordered traversal and quick-range searches.	Does not maintain any order; element arrangement is determined by the hash function.
Performance for Basic Operations	Somewhat increased temporal complexity; operations like add, delete, and contain are ?(log⁡?)O(logN).	Constant-time complexity ?(1)O(1) for basic operations like add, delete, and contain, making it highly efficient.
Best Use Case	Better suited for applications requiring ordered data management, such as range queries or sequential access.	Ideal for scenarios where quick retrieval and manipulation are more important than element order.
Sorting	Automatically sorts elements according to their natural ordering or a specified comparator.	No sorting of elements; storage is hash-based.
Application Suitability	Preferred for applications where elements need to be maintained in a sorted manner.	More suitable for applications requiring fast access and where element order is not a concern.

Next TopicJava PriorityQueue class

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

[email protected]

+91-9599086977

Interview Questions

Python Java Data Structure C++ C HTML JavaScript jQuery SQL Power BI

Online Compilers

C Compiler R Compiler C++ Compiler PHP Compiler Java Compiler HTML Editor Swift Compiler Python Compiler JavaScript Editor TypeScript Editor

Latest Post | Tutorials List | Privacy Policy | About Us | Contact Us

Java TreeSet Class

Internal Working of The TreeSet Class

Key Aspects of TreeSet's Functionality

Synchronization of The TreeSet Class

Synchronization of The TreeSet Class

Hierarchy of theTreeSet Class

TreeSet Class Declaration

Components of the Declaration

Constructors of Java TreeSet Class

Methods of Java TreeSet Class

Java TreeSet Examples

Java TreeSet Example 1:

Java TreeSet Example 2:

Java TreeSet Example 3:

Java TreeSet Example 4:

Java TreeSet Example 5:

Java TreeSet Example: Book

ClassCast Exception in TreeSet

TreeSet Vs. HashSet

Contact info

Follow us

Top Tutorials

Interview Questions

Online Compilers

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java String

Java Regex

Exception Handling

Java Inner Class

Java Multithreading

Java Synchronization

Java I/O

File Handling in Java

Java Serialization

Java Networking

Java Reflection

Java Collections

Java 5 Features

Java 8 Features

Java JDBC

RMI

Internationalization

Java Projects

Java TreeSet Class

Internal Working of The TreeSet Class

Key Aspects of TreeSet's Functionality

Synchronization of The TreeSet Class

Synchronization of The TreeSet Class

Hierarchy of theTreeSet Class

TreeSet Class Declaration

Components of the Declaration

Constructors of Java TreeSet Class

Methods of Java TreeSet Class

Java TreeSet Examples

Java TreeSet Example 1:

Java TreeSet Example 2:

Java TreeSet Example 3:

Java TreeSet Example 4:

Java TreeSet Example 5:

Java TreeSet Example: Book

ClassCast Exception in TreeSet

TreeSet Vs. HashSet

Related Posts

Subscribe to Tpoint Tech

Contact info

Follow us

Top Tutorials

Interview Questions

Online Compilers