Mid Month Offer - Upto 40% Off | OFFER ENDING IN: 0 D 0 H 0 M 0 S

Log In to start Learning

Login via

  • Home
  • Blog
  • Understanding Java TreeSet ...
Post By Admin Last Updated At 2021-08-31
Understanding Java TreeSet With Examples

We all know that Java is a powerful and popular programming language for different needs in IT. Also, the Collections in Java application plays a very important role that offers different types of classes and interfaces. Java TreeSet is one such type of Collection that stores the data naturally in ascending order. It avoids any duplication in the storage of data. Moreover, a Java TreeSet is the major inference under the SortedSet interface within the Java programming language. Also, it stores data within a tree format. 

The ordering of a TreeSet is implemented in a natural ordering way. Moreover, a TreeSet Class that implements Java TreeSet, inherits the Abstract Class in Java and implements the NavigableSet interface. 

This is a brief intro to the Java TreeSet and now we will move into a deep dive into this topic. 

Java TreeSet

Java TreeSet 

Let us understand the Java TreeSet in detail. We should note that we can order Java TreeSet elements clearly by providing the personalized Comparator while building a TreeSet object. Here we can use a particular constructor prototype to create TreeSet. Thus, Java TreeSet has the following important characteristics.:-

  • TreeSet class in Java applies the SortedSet interface and also it avoids duplicate elements.
  • A TreeSet class within Java is non-synchronized.
  • Further, a TreeSet doesn’t protect the placing order of elements. But the elements within the TreeSet sort out as per the ordering in a natural way.
  • While we build a Java TreeSet, we can order TreeSet elements through a custom Comparator.
  • Moreover, a Java TreeSet is useful for storing data sort out naturally which makes access much easier and faster.
Java TreeSet Class Declaration

Java programming offers a class known as “TreeSet” that includes the TreeSet data structure functionality. Also, the Java TreeSet class is a subpart of the “java.util package”.

Moreover, we should use the following import statement in order to include the TreeSet class in Java.

import java.util.*;

Now let us set the declaration for the TreeSet class within Java TreeSet;

In this class declaration, we see that TreeSet extends the AbstractSet elements. Then it applies the NavigableSet, Cloneable, and Serializable interfaces accordingly. 

Get into Core Java Online Course with Onlineitguru where you can enhance your skills in Java programming for a better future.

Java TreeSet example

Here we look into the basic example for Java TreeSet.

import java.util.*;  

class TreeSet1{  

 public static void main(String args[]){  

  //Create and add elements here

  TreeSet al=new TreeSet();  

  al.add("R");  

  al.add("V");  

  al.add("K");  

  al.add("A");  

  //Cross the elements  

  Iterator itr=al.iterator();  

  while(itr.has Next()){  

   System.out.print ln(itr.next());  

  }  

 }  

}  

Output - The following output we can see here.

A

R

V

Similarly, we can also check the crossing of the elements in descending order, and also we can retrieve the highest or lowest values. 

||{"title":"Master in Core Java", "subTitle":"Core Java Certification Training by ITGURU's", "btnTitle":"View Details","url":"https://onlineitguru.com/core-java-online-training-placement.html","boxType":"demo","videoId":"Vi7pdpk5Vq0"}||

How does a Java TreeSet work?

Let us know the various operations that Java TreeSet is useful to perform.

Add Elements:

While adding an element to the Java TreeSet, we can use the add() method. Although, for the placing of an order in the Java TreeSet there is no protection. The values are compared and classified in ascending order which is internal for each and every element. Here, we need to keep in mind that duplicate elements should be ignored and it doesn’t allow them. Furthermore, a TreeSet doesn’t accept the Null values.

Example:

import java.util.*; 

class TreeSetExample {

    public static void main(String[] args)

    {

        Set ts = new TreeSet<>();

        ts.add("Learn");

        ts.add("Today");

        ts.add("Grow");

        System.out.println(ts);

    }

}

Output

[Grow, Learn, Today]

Element’s Access

You have seen how to add elements to a set in a Java TreeSet. Now if you want to access those elements then you have to use some inbuilt methods such as contains(), first(), last(), and so on. 

Similarly, we can Remove the values upon adding the values to the TreeSet using Remove() method. Here there are different methods we can use to remove the first or last value.

Thereafter, comes iteration through the TreeSet where we can use the enhanced for loop method for iteration. The following example of TreeSet can give you a better idea of this method.

import java.util.*;

class TreeSetExample {

    public static void main(String[] args)

    {

        Set ts = new TreeSet<>(); 

        ts.add("Grow");

        ts.add("Study");

        ts.add("Learn");

        ts.add("C");

        ts.add("D");

        ts.add("K");

        for (String value : ts)

            System.out.print (value + ", ");

        System.out.println ();

    }

}

Output

[C, D, Grow, K, Learn, Study]

Features of Java TreeSet

The following features we can see importantly within a Java TreeSet.

A Java TreeSet applies the interface SortedSet so we cannot include duplicate values in it.

For the objects within a TreeSet, we can divide them to categorize in a Sorted or classified method and in ascending order.

In case, we are following the default natural sorting order, then the objects we infuse into the TreeSet should identical and similar. Further, if a user tries to add any diverse objects while insertion, it will throw an exception at Runtime. 

Moreover, a TreeSet can accept only the common types that are similar and applies the Comparable interfaces. 

Hence, a Java TreeSet can be a good choice for storing a huge amount of classified information. Because that is easier and quickly accessible and has faster retrieval time also.

While a user inserts a null value, it throws a NullPointerException because a null value cannot be comparable. 

TreeSet methods in Java

A TreeSet applies SortedSet so there is the availability of different types of methods in Collection, Set interface, and Sorted Set interfaces. There are different types of methods available in the Java TreeSet. Let us look into these methods of TreeSet in detail.

add(Object o)

This method will help to add the defined element to the set. This will follow the same sorting order given during the designing of the Java TreeSet. We also need to take care while duplicate values are not get added to the tree.

addAll(Collection c)

This method will help to add all the elements of a defined Collection to the TreeSet. Moreover, all the elements within collections should be equivalent otherwise it will throw an exception. It is to keep in mind that duplicate entries of collection shouldn’t be added to the Java TreeSet.

clear()

This clear method will help to eliminate or delete all the elements. 

Object clone()

The clone method is useful to return a shallow copy of the TreeSet which is nothing but a simple copied set.

first()

This method in TreeSet helps to return the first(lowest) element stored within the tree set.

last()

The last method will return the last(highest) element within the TreeSet.

isEmpty()

This method will return a true value if the TreeSet is empty or contains no value.

contains (Object o)

It returns True in case it contains all the given elements.

Comparator comparator()

This method helps to return the Comparator that is used for sorting the elements within the TreeSet.

descendingiterator()

It is useful to iterate the elements in descending order within a tree set.

descendingset()

This method will return a reverse order of the elements included within the given set.

spliterator()

The method builds a late-binding and fail-fast spliterator over the given elements within a Tree Set.

In this way, there are many methods available in the TreeSet that we can use. Now we will put a light on the constructors of the TreeSet class.

Constructors of the Java TreeSet class

A TreeSet class offers the following four types of constructors such as:

TreeSet()

It helps to create an empty TreeSet with a default classified order. In other words, this constructor is useful to create an empty tree set where the elements get classified in a natural classified order. 

TreeSet(Collection)

This constructor is useful to design a TreeSet object that includes all the elements of the given collection. Here also the elements will get sorted out through a natural sorting order which is the default.  It is useful where there is a need to convert from any Collection object to a TreeSet object.

TreeSet (Comparator)

The constructor helps to design an empty TreeSet with given comparator order of classifying the elements while storing them.

TreeSet (Sorted Set)

Useful to create a TreeSet object including elements from a given sorted set. This is also a similar set where elements will get classified with natural sorting order. 

Hence, these are the different constructors available in a tree set class. 

||{"title":"Master in Core Java", "subTitle":"Core Java Certification Training by ITGURU's", "btnTitle":"View Details","url":"https://onlineitguru.com/core-java-online-training-placement.html","boxType":"reg"}||

TreeSet vs HashSet

Here you will find out the basic difference between the TreeSet and HashSet.

  • In a TreeSet, we can order all elements using the default naturing ordering system. But in HashSet, there is no such element order.
  • A TreeSet takes 0 (log N) time for conducting operations such as insert, remove, search, etc. which makes it slower than TreeSet to function. Where on the other hand, HashSet takes constant time to do basic operations as above. It makes the hash set faster than the TreeSet.
  • A tree set doesn’t allow any null objects or duplicate objects. But HashSet allows such objects in its functions.
  • In HashSet, there are two methods: compare() and equals () are useful in comparing two objects. But in Tree Set, there is only one method compareTo() to compare any two objects.
  • A tree set is internally applied through Navigable TreeMap but a HashSet is internally applicable using Hashmap. 
Final Words

Thus, you have gone through the different Java TreeSet examples and the purpose of using TreeSet. It is clearly mentioned that a Java TreeSet is useful to store the information naturally in ascending order. So, it basically stores the information through a tree set making it in a certain order. There are numerous methods and constructors used in this regard for different purposes. 

If you wish to know more about the Java language, then you can opt for OnlineItGuru’s Core Java Online Training program. This program is designed to make you aware of various concepts of Core Java where expert mentors will guide you in real-time. You will get the experience of learning programming in real-time with a practical approach.