TreeSet is a class in the Java Collection Framework that implements the SortedSet interface. It stores elements in ascending order and does not allow duplicate values, so access and retrieval times become faster. Because of this excellent functionality, TreeSets are often used to store large amounts of information that need to be searched quickly. We will use the Comparable interface to sort a given TreeSet and then, using built-in methods, try to get the highest and lowest value elements from that TreeSet.
Before entering the program, let us first familiarize ourselves with some concepts
This interface is useful when we want to sort custom objects in their natural order. For example, it sorts strings lexicographically and numbers numerically. This interface is available in the "java.lang" package. Generally speaking, the classes and interfaces defined in this package are available to us by default, so there is no need to import this package explicitly.
class nameOfclass implements Comparable<nameOfclass>
Here, class is the keyword to create a class, and implements is the keyword that allows the use of the functions provided by the interface.
The Comparable interface only defines a method called "CompareTo" which can be overridden to sort a collection of objects. It provides the ability to compare objects of a class with itself. Returns 0 when the "this" object is equal to the passed object, a positive value if the "this" object is greater, and a negative value otherwise.
compareTo(nameOfclass nameOfobject);
Both methods are used with TreeSet objects and take no parameters. The ‘last()’ method returns the end element of the specified TreeSet, and the ‘first()’ method returns the element at the first position. Since a TreeSet stores its elements in ascending order, the last element is considered as the highest value element and vice versa as the lowest value element.
First, import the "java.util" package so that we can use TreeSet
Create a class "Cart" that implements Comparable Interface. In it declare two variables and define the constructor of the class and the two parameters "item" and "price" of type string and integer respectively.
Define the "compareTo" method along with an object of the "Cart" class as a parameter to compare the "this" object with the newly created object.
Now, in the main() method, declare an object named "trSet" of class "Cart" of collection type TreeSet and add the details of the object using the inbuilt method named "add()" Store to collection.
Finally, call the built-in methods "last()" and "first()" to obtain the highest and lowest values respectively.
The following example demonstrates how to find the highest and lowest value elements from a TreeSet.
import java.util.*; public class Cart implements Comparable <Cart> { String item; int price; Cart(String item, int price) { // constructor // this keyword shows these variables belong to constructor this.item = item; this.price = price; } // overriding method public int compareTo(Cart comp) { if(this.price > comp.price) { // performing comparison return 1; } else { return -1; } } public String toString() { return "Item: " + this.item + ", Price: " + this.price; } public static void main(String[] args) { // Declaring collection TreeSet TreeSet <Cart> trSet = new TreeSet <Cart>(); // Adding object to the collection trSet.add(new Cart("Rice", 59)); trSet.add(new Cart("Milk", 60)); trSet.add(new Cart("Bread", 45)); trSet.add(new Cart("Peanut", 230)); trSet.add(new Cart("Butter", 55)); // to print the objects for (Cart print : trSet) { System.out.println("Item: " + print.item + ", " + "Price: " + print.price); } // calling in-built methods to print required results System.out.println("Element having highest value: " + trSet.last()); System.out.println("Element having lowest value: " + trSet.first()); } }
Item: Bread, Price: 45 Item: Butter, Price: 55 Item: Rice, Price: 59 Item: Milk, Price: 60 Item: Peanut, Price: 230 Element having highest value: Item: Peanut, Price: 230 Element having lowest value: Item: Bread, Price: 45
We first defined the TreeSet class of the Java Collection Framework. In the next section, we discovered the Comparable interface and some built-in methods that help us use the sorting logic on the TreeSet to get the highest and lowest value elements from the Set.
The above is the detailed content of Use the sorting logic of TreeSet in Java to get the maximum and minimum elements in the set. For more information, please follow other related articles on the PHP Chinese website!