Skip to content
Related Articles

Related Articles

How to Sort HashSet Elements using Comparable Interface in Java?
  • Last Updated : 19 Jan, 2021

The HashSet class implements the Set interface, backed by a hash table which is actually a HashMap instance. No guarantee is made as to the iteration order of the set which means when we iterate the HashSet, there is no guarantee that we get elements in which order they were inserted.

To sort HashSet elements using Comparable interface in java first, we create a class Student that implements the Comparable interface. In this class we override the compareTo() method.

Pseudo Code:

// Student class implements comparable interface

class Student implements Comparable<Student> {
    Integer marks;
    
    Student(Integer marks) {
        this.marks = marks;
    }
    
    // override toString method
    public String toString() {
        return (" " + this.marks);
    }
    
    // Override compareTo method to sort LinkedHashSet in accending order
    public int compareTo(Student stu) {
        return this.marks.compareTo(stu.marks);
    }
}

And then we pass the set to the TreeSet constructor to sort the elements.

// TreeSet to sort LinkedHashSet using comparable

TreeSet<Student> tree_set = new TreeSet<>(set);

Below is the full implementation of the above approach:



Example 1:

Java




// Java program to demonstrate how to Sort HashSet using
// Comparable interface
  
import java.util.*;
  
// Student class implements comparable interface
class Student implements Comparable<Student> {
    
    Integer marks;
  
    Student(Integer marks) { this.marks = marks; }
  
    // override toString method
    public String toString() { return (" " + this.marks); }
  
    // Override compareTo method to sort HashSet in
    // accending order
    public int compareTo(Student stu)
    {
        return this.marks.compareTo(stu.marks);
    }
}
  
class GFG {
    public static void main(String[] args)
    {
  
        // New HashSet
        HashSet<Student> set = new HashSet<>();
  
        // Adding elements to the set
        set.add(new Student(500));
        set.add(new Student(300));
        set.add(new Student(400));
        set.add(new Student(100));
        set.add(new Student(200));
  
        // Print Before sort
        System.out.println("Before sort elements in ascending order : "
            + set);
  
        // TreeSet to sort HashSet using comparable
        // interface
        TreeSet<Student> tree_set = new TreeSet<>(set);
  
        // Print after sorting
        System.out.println("After sort elements in ascending order : "
            + tree_set);
    }
}
Output
Before sort elements in ascending order : [ 300,  400,  500,  200,  100]
After sort elements in ascending order : [ 100,  200,  300,  400,  500]

Example 2:

Java




// Java program to demonstrate how to Sort HashSet using
// Comparable interface
  
import java.util.*;
  
// Student class implements comparable interface
class Student implements Comparable<Student> {
    
    Integer marks;
  
    Student(Integer marks) { this.marks = marks; }
  
    // override toString method
    public String toString() { return (" " + this.marks); }
  
    // Override compareTo method to sort HashSet in
    // decending order
    public int compareTo(Student stu)
    {
        return stu.marks.compareTo(this.marks);
    }
}
  
class GFG {
    public static void main(String[] args)
    {
  
        // New HashSet
        HashSet<Student> set = new HashSet<>();
  
        // Adding elements to the set
        set.add(new Student(500));
        set.add(new Student(300));
        set.add(new Student(400));
        set.add(new Student(100));
        set.add(new Student(200));
  
        // Print Before sort
        System.out.println("Before sort elements in descending order : "
            + set);
  
        // TreeSet to sort HashSet using comparable
        // interface
        TreeSet<Student> tree_set = new TreeSet<>(set);
  
        // Print after sorting
        System.out.println("After sort elements in descending order : "
            + tree_set);
    }
}
Output
Before sort elements in descending order : [ 300,  400,  500,  200,  100]
After sort elements in descending order : [ 500,  400,  300,  200,  100]

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :