Creación de TreeSet con comparador por objetos definidos por el usuario en Java

TreeSet es la clase de implementación de Set Interface. Sigue un orden de clasificación natural o puede personalizarlo usando un comparador y tampoco permite duplicados.

Sintaxis:

TreeSet<String> gfg= new TreeSet<>();

A continuación se muestra la implementación normal del TreeSet:

// Java program for TreeSet
import java.io.*;
import java.util.TreeSet;
 
class GFG {
    public static void main(String[] args)
    {
         
        TreeSet<String> gfg = new TreeSet<String>();
 
        // adding elements in Treeset using add() method
        gfg.add("first");
        gfg.add("second");
        gfg.add("third");
        gfg.add("fourth");
        gfg.add("fifth");
 
        // iterating over the TreeSet using
        // foreach loop and printing it
        for (String value : gfg) {
            System.out.println(value);
        }
    }
}

fifth
first
fourth
second
third

Creación de TreeSet con Comparator para objetos definidos por el usuario

1. Uso de interfaces para hacer un objeto comparador: 

Primero, crearemos una clase de empleado que tenga los atributos edad, id, nombre y un constructor predeterminado y un constructor parametrizado. Ahora necesitamos crear las clases Comparator implementando la interfaz del comparador y necesitamos anular el método compare(). El tipo de retorno para el método de comparación es un número entero (1, -1, 0).

Por ejemplo Objetos como (Objeto o1, Objeto o2)  

Para orden ascendente (Enteros)  

if(o1<o2) return -1;
else if(o1>o2) return +1;
else return 0;

Para orden descendente (Enteros)

if(o1<o2) return +1;
else if(o1>o2) return -1;
else return 0;

Para strings en orden ascendente

return s1.compareTo(s2); //here s1 , s2 are strings

Para strings en orden descendente

return -s1.compareTo(s2);//here s1 , s2 are strings

Ahora crearemos un TreeSet de empleados y empleados en él y en el constructor, debemos pasar el objeto comparador.

Sintaxis:

TreeSet<Employees> gfg=new TreeSet<>(comparatorObject);
gfg.add(new Employee(1,"raja",23);

A continuación se muestra la implementación del enunciado del problema anterior:

// Java program for treeset of user
// defined objects and using comparator
 
import java.io.*;
import java.util.Comparator;
import java.util.TreeSet;
 
class GFG {
    public static void main(String[] args)
    {
        // TreeSet of user defined objects
        // and using comparator also
        // we will create TreeSet of employees
        System.out.println(
            "Sorting on the basis of name in Ascending order");
 
        // passed first comparator object for
        // sorting in ascending order of name
        TreeSet<Employee> gfg
            = new TreeSet<>(new FirstComparator());
 
        gfg.add(new Employee(1, "ram", 24));
        gfg.add(new Employee(2, "krishna", 23));
        gfg.add(new Employee(3, "sita", 26));
        gfg.add(new Employee(4, "lakshman", 25));
 
        // printing each employee object
        for (Employee employee : gfg) {
            System.out.println(employee);
        }
 
        System.out.println(
            "Sorting on the basis of name in Descending order");
 
        // Passed second comparator object for
        // Sorting in descending order of name
        TreeSet<Employee> gfg2
            = new TreeSet<>(new SecondComparator());
        gfg2.add(new Employee(1, "ram", 24));
        gfg2.add(new Employee(2, "krishna", 23));
        gfg2.add(new Employee(3, "sita", 26));
        gfg2.add(new Employee(4, "lakshman", 25));
 
        // printing each employee object
        for (Employee employee : gfg2) {
            System.out.println(employee);
        }
 
        // ThirdComparator
        System.out.println(
            "Sorting on the basis of age in ascending order");
 
        TreeSet<Employee> gfg3
            = new TreeSet<>(new ThirdComparator());
 
        gfg3.add(new Employee(1, "ram", 24));
        gfg3.add(new Employee(2, "krishna", 23));
        gfg3.add(new Employee(3, "sita", 26));
        gfg3.add(new Employee(4, "lakshman", 25));
 
        // printing each employee object
        for (Employee employee : gfg3) {
            System.out.println(employee);
        }
    }
}
 
// for sorting in ascending order
class FirstComparator implements Comparator<Employee> {
    @Override public int compare(Employee e1, Employee e2)
    {
        return (e1.name).compareTo(e2.name);
    }
}
 
// for sorting in descending order
// passed in reverse order e2 first than e1
class SecondComparator implements Comparator<Employee> {
    @Override public int compare(Employee e1, Employee e2)
    {
        return -(e1.name).compareTo(e2.name);
    }
}
 
// Sorted on the basis of age
class ThirdComparator implements Comparator<Employee> {
    @Override public int compare(Employee e1, Employee e2)
    {
        if (e1.age > e2.age) {
            return -1;
        }
        else if (e1.age < e2.age) {
            return 1;
        }
        else {
            return (e1.age).compareTo(e2.age);
        }
    }
}
 
// Employee class
class Employee {
 
    // Employee has three attributes
    // id , name, age
 
    public int id;
    public String name;
    public Integer age;
 
    // default constructor
    Employee() {}
 
    // parameterized constructor
    Employee(int id, String name, int age)
    {
        this.id = id;
        this.name = name;
        this.age = age;
    }
 
    @Override public String toString()
    {
        return "" + this.id + " " + this.name + " "
            + this.age;
    }
}

Sorting on the basis of name in Ascending order
2 krishna 23
4 lakshman 25
1 ram 24
3 sita 26
Sorting on the basis of name in Descending order
3 sita 26
1 ram 24
4 lakshman 25
2 krishna 23
Sorting on the basis of age in ascending order
3 sita 26
4 lakshman 25
1 ram 24
2 krishna 23

2. Usando la expresión lambda de Java 8:

Aquí no crearemos las clases separadas que implementarán la interfaz del comparador y, por lo tanto, no es necesario anular el método de comparación. Ahora simplemente necesitamos usar las expresiones lambda directamente en el constructor de TreeSet, el resto de las cosas son las mismas, la única diferencia aquí es que estamos usando lambda para el objeto comparador.

Sintaxis: 

TreeSet<Employee> gfg2=new TreeSet<>(
(Employee e1 , Employee e2)->e1.name.compareTo(e2.name));

A continuación se muestra la implementación del enunciado del problema: 

// Java program for treeset of user
// defined objects and using comparator
 
import java.io.*;
import java.util.Comparator;
import java.util.TreeSet;
 
class GFG {
    public static void main(String[] args)
    {
        // TreeSet of user defined objects
        // we will create TreeSet of employees
        System.out.println(
            "Sorting on the basis of name ascending order");
 
        // passing comparator using lambda expressions
        TreeSet<Employee> gfg
            = new TreeSet<>((Employee e1, Employee e2)
                                ->
                            - (e1.name).compareTo(e2.name));
 
        gfg.add(new Employee(1, "ram", 24));
        gfg.add(new Employee(2, "krishna", 23));
        gfg.add(new Employee(3, "sita", 26));
        gfg.add(new Employee(4, "lakshman", 25));
 
        for (Employee employee : gfg) {
            System.out.println(employee);
        }
 
        // SecondComparator
        System.out.println(
            "Sorting on the basis of name ascending order");
 
        TreeSet<Employee> gfg2 = new TreeSet<>(
            (Employee e1,
             Employee e2) -> e1.name.compareTo(e2.name));
 
        // adding employee object to treeSet
        gfg2.add(new Employee(1, "ram", 24));
        gfg2.add(new Employee(2, "krishna", 23));
        gfg2.add(new Employee(3, "sita", 26));
        gfg2.add(new Employee(4, "lakshman", 25));
 
        // printing every employee object
        for (Employee employee : gfg2) {
            System.out.println(employee);
        }
    }
}
 
class Employee {
    // Employee has three attributes
    // id , name, age
 
    public int id;
    public String name;
    public Integer age;
 
    // default constructor
    Employee() {}
 
    // parameterized constructor
    Employee(int id, String name, int age)
    {
        this.id = id;
        this.name = name;
        this.age = age;
    }
 
    @Override public String toString()
    {
        return "" + this.id + " " + this.name + " "
            + this.age;
    }
}

Sorting on the basis of name ascending order
3 sita 26
1 ram 24
4 lakshman 25
2 krishna 23
Sorting on the basis of name ascending order
2 krishna 23
4 lakshman 25
1 ram 24
3 sita 26