La clase TreeSet en Java es parte del marco de colecciones de Java que implementa la interfaz NavigableSet , que proporciona funcionalidades para navegar a través de SortedSet. El NavigableSet amplía aún más la interfaz SortedSet , que proporciona funcionalidades para mantener los elementos ordenados.
Como la clase TreeSet implementa una interfaz NavigableSet, tiene características de ambos: NavigableSet y SortedSet.
El TreeSet clasifica u ordena los elementos según el orden natural. Todas las clases Wrapper y la clase String ya implementan la interfaz Comparable. Pero en el caso de objetos personalizados, uno tiene que implementar interfaces Comparables o Comparadores en la clase correspondiente, para que TreeSet pueda ordenar los objetos como deseemos.
TreeSet con objetos definidos por el usuario
Se dice que un objeto es comparable si y solo si la clase correspondiente implementa la interfaz Comparable o Comparator. El método compare() de la interfaz Comparator y el método compareTo() de la interfaz Comparable proporcionan la lógica de clasificación a TreeSet, lo que permite que TreeSet inserte valores en consecuencia. Ahora, si desea evitar cualquier entrada duplicada de objetos en TreeSet, debe implementar estas interfaces con verificación de igualdad . Y podemos hacer esto de múltiples maneras,
Ejemplo:
1. Usando la interfaz comparable: Hagamos una clase de estudiante, Estudiante, que incluya el nombre del estudiante y el rango del estudiante en cualquier curso. Aquí, no más de un estudiante puede tener el mismo rango. Por lo tanto, si se realiza una nueva entrada de cualquier estudiante con un rango que anteriormente ocupaba otro estudiante, entonces esa entrada sería una entrada duplicada. De lo contrario, el estudiante será ordenado en base a su nombre en orden ascendente.
Anule el método compareTo() para proporcionar la lógica de clasificación. En el método compareTo() de la interfaz Comparable, primero verificamos si los rangos de los dos objetos de estudiante son iguales, si son iguales, luego devolvemos 0, lo que significa que los dos objetos son iguales. De lo contrario, si el rango no es el mismo, compare los nombres de los objetos de estudiante y devuelva 1 o -1 según corresponda.
Java
// Java Program to Avoid Duplicate User
// Defined Objects in TreeSet
import java.util.*;
// implementing comparable interface
public class Student implements Comparable<Student> {
private String name;
private int rank;
// constructor
Student(String name, int rank)
{
this.name = name;
this.rank = rank;
}
// returns the student name
private String getName() { return name; }
// returns student rank
public int getRank() { return rank; }
/*
overriding compareTo() method.
if the object has same rank then it is considered as a
duplicate entry, else, the entry is sorted on the
basis of the student name.
*/
@Override public int compareTo(Student o)
{
if (rank == o.getRank()) {
return 0;
}
else if (name.compareTo(o.getName()) < 0) {
return -1;
}
else
return 1;
}
// overriding toString() to print the student detail
@Override public String toString()
{
return name + " (" + rank + ")";
}
}
// driver class
class Gfg {
public static void main(String args[])
{
// create a TreeSet which stores objects of type
// Student
TreeSet<Student> students = new TreeSet<>();
// add objects to the TreeSet
students.add(new Student("Raghav", 12));
students.add(new Student("Tilak", 11));
// adding an object with same rank
students.add(new Student("Ayush", 12));
// adding an object with same name but different
// rank
students.add(new Student("Raghav", 32));
// print the TreeSet
for (Student s : students) {
System.out.println(s);
}
}
}
Raghav (12) Raghav (32) Tilak (11)
2. Usando la interfaz del comparador: hagamos una clase de empleado que tenga el nombre y la identificación del empleado. Aquí, dos o más empleados no pueden tener las mismas identificaciones. Y los empleados se clasifican en función de sus identificaciones. (También podemos implementar la misma lógica que la anterior en este método). Mientras usa Comparator, pase la instancia del comparador en el constructor del TreeSet mientras crea uno. Esto asegura que TreeSet esté ordenado de la manera que deseamos y no por el ordenamiento natural utilizado por TreeSet.
Java
// Java Program to Avoid Duplicate User
// Defined Objects in TreeSet
import java.util.*;
// implementing comparator interface
public class Employee implements Comparator<Employee> {
private String name;
private int id;
// constructor
public Employee(String name, int id)
{
this.name = name;
this.id = id;
}
// default constructor is required, since we have to
// pass the instance of Comparator in the constructor,
// while creating a TreeSet
public Employee() {}
// returns employee name
public String getName() { return name; }
// returns id of the employee
public int getId() { return id; }
/*
overriding the compare() method, this method compare
two objects of type Employee on the basis of their id,
if the ids of two employees is same then its considered
a duplicate entry. else, it is sorted of the basis of
id.
*/
@Override
public int compare(Employee emp1, Employee emp2)
{
if (emp1.getId() == emp2.getId()) {
return 0;
}
else if (emp1.getId() < emp2.getId()) {
return -1;
}
else {
return 1;
}
}
// overriding toString() to print the employee detail
@Override public String toString()
{
return name + " (" + id + ")";
}
}
// driver class
class Gfg {
public static void main(String args[])
{
// create a TreeSet which stores objects of type
// Employee
TreeSet<Employee> employees
= new TreeSet<>(new Employee());
// add objects to the TreeSet
employees.add(new Employee("Raghav", 934));
employees.add(new Employee("Tilak", 435));
employees.add(new Employee("Mumukshi", 252));
// adding an object with same id
employees.add(new Employee("Shalu", 934));
// printing the TreeSet
for (Employee s : employees) {
System.out.println(s);
}
}
}
Mumukshi (252) Tilak (435) Raghav (934)