¿Cómo ordenar los elementos HashSet usando una interfaz comparable en Java?

La clase HashSet implementa la interfaz Set , respaldada por una tabla hash que en realidad es una instancia de HashMap . No se garantiza el orden de iteración del conjunto, lo que significa que cuando iteramos el HashSet, no hay garantía de que obtengamos los elementos en el orden en que se insertaron.

Para ordenar los elementos HashSet usando la interfaz Comparable en Java primero, creamos una clase Student que implementa la interfaz Comparable. En esta clase anulamos el método compareTo() .

Pseudocódigo:

// 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 ascending order
    public int compareTo(Student stu) {
        return this.marks.compareTo(stu.marks);
    }
}

Y luego pasamos el conjunto al constructor TreeSet para ordenar los elementos.

// TreeSet to sort LinkedHashSet using comparable

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

A continuación se muestra la implementación completa del enfoque anterior:

Ejemplo 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
    // ascending 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);
    }
}
Producción

Before sort elements in ascending order : [ 300,  400,  500,  200,  100]
After sort elements in ascending order : [ 100,  200,  300,  400,  500]

Ejemplo 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
    // descending 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);
    }
}
Producción

Before sort elements in descending order : [ 300,  400,  500,  200,  100]
After sort elements in descending order : [ 500,  400,  300,  200,  100]

Publicación traducida automáticamente

Artículo escrito por KapilChhipa y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *