TreeSet constructeur avec le paramètre Comparator <?>
Dans la documentation de Java pour sa classe TreeSet, l’un des constructeurs possède l’en-tête suivant:
TreeSet(Comparator<? super E> c)
Quelqu'un peut-il aider à expliquer pourquoi il existe un constructeur pour TreeSet qui prend un objet comparateur comme argument? Je ne sais pas pourquoi cela est fait.
Les éléments d'un TreeSet sont triés.
Si vous utilisez un constructeur qui n'a pas de comparateur, l'ordre naturel de la classe d'éléments (défini par l'implémentation de Comparable) sera utilisé pour trier les éléments du TreeSet.
Si vous souhaitez un ordre différent, vous fournissez un comparateur dans le constructeur.
Ce constructeur vous permet de définir la Comparator utilisée lors de l'insertion d'une T dans l'arborescence située derrière la Set.
Comparator<String> comp = (String o1, String o2) -> (o1.compareTo(o2));
Set<String> ts = new TreeSet<>(comp);
Toutes les réponses ci-dessus sont correctes, mais j’aimerais ajouter qu’un comparateur personnalisé, mis à part un tri différent, filtrera également les valeurs différemment.
Puisque les valeurs de Set sont univoques, si le comparateur personnalisé renvoie que deux valeurs sont identiques, une seule d'entre elles apparaîtra dans l'ensemble:
Set<String> s = new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.trim().compareTo(s2.trim());
}
});
s.add("1");
s.add(" 1");
s.add("2 ");
s.add("2");
s.add(" 2 ");
Arrays.toString(s.toArray()); // [ "1", "2 "]
Il est utilisé pour trier les éléments de l'ensemble en fonction de règles définies par l'utilisateur.
Voir le javadoc :
public TreeSet (comparateur de comparaison)
Construit un nouveau, ensemble d'arborescence vide, trié en fonction du comparateur spécifié _.
Tout les éléments insérés dans le jeu doivent être mutuellement comparables par le comparateur spécifié: comparator.compare (e1, e2) ne doit pas lancer de ClassCastException pour tous les éléments e1 et e2 de l'ensemble.
Si l'utilisateur tente d'ajouter à l'ensemble un élément qui ne respecte pas cette contrainte, l'appel add lancera une exception ClassCastException.
Paramètres:
comparateur - le comparateur qui sera utilisé pour commander cet ensemble. Si null, l'ordre naturel des éléments Sera utilisé.
Voir ici pour plus d’informations sur la commande des objets naturels.
La classe Treeset a le constructeur ci-dessous, de sorte que Treeset stocke l'élément en utilisant le dans l'ordre décrit par le comparateur c.
**Constructor :-**
TreeSet(Comparator<? super E> c)
class Employeee {
public Employeee(int id, String name) {
super();
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private int id;
private String name;
}
class namecomp implements Comparator<Employeee> {
public int compare(Employeee paramT1, Employeee paramT2) {
if (paramT1.getName().compareTo(paramT2.getName()) > 0)
return -1;
else if (paramT1.getName().compareTo(paramT2.getName()) < 0)
return 1;
else
return 0;
}
}
public class TreeSetImpl {
public static void main(String[] args) {
SortedSet<Employeee> treeSet = new TreeSet<Employeee>(new namecomp());
Employeee e1 = new Employeee(1, "Iftekhar");
Employeee e2 = new Employeee(2, "Khan");
Employeee e3 = new Employeee(3, "Apple");
treeSet.add(e1);
treeSet.add(e2);
treeSet.add(e3);
Iterator<Employeee> it = treeSet.iterator();
while (it.hasNext()) {
System.out.println(it.next().getId());
}
}
}
Si vous voyez que namecomp implémente l'interface de comparateur, triez ainsi les éléments de la classe Employeee dans l'ordre décroissant en fonction du champ Nom . ordre sur la base du champ Nom . Sortie 2 1 3
J'espère que cela répond à la question.
Un TreeSet est un arbre de recherche binaire , qui repose sur la notion selon laquelle, étant donné que deux éléments a et b, soit a est "plus petit que" b ou pas. Toutefois, si vous définissez votre propre classe, la variable TreeSet ne sait pas comment déterminer si un objet donné de cette classe est "plus petit que" un autre objet, car il ne peut pas connaître votre interprétation du contenu de ces objets. Par conséquent, vous pouvez créer une Comparator qui peut effectuer les comparaisons pour le compte de la TreeSet.
The following code shows how to use TreeSet.TreeSet(Comparator <? super E > comparator) constructor.
/**
*Output:
F E D C B A
*/
import Java.util.Comparator;
import Java.util.TreeSet;
class MyComparator implements Comparator<String> {
public int compare(String a, String b) {
String aStr, bStr;
aStr = a;
bStr = b;
return bStr.compareTo(aStr);
}
// No need to override equals.
}
public class MainClass {
public static void main(String args[]) {
TreeSet<String> ts = new TreeSet<String>(new MyComparator());
ts.add("C");
ts.add("A");
ts.add("B");
ts.add("E");
ts.add("F");
ts.add("D");
for (String element : ts)
System.out.print(element + " ");
System.out.println();
}
}
Comparator interface is used to order the objects of user-defined class.
Il fournit plusieurs séquences de tri, c’est-à-dire que vous pouvez trier les éléments en fonction de tout membre de données. Par exemple, il peut s'agir de rollno, nom, âge ou autre chose.
En passant un comparateur dans TreeSet(Comparator<? super E> c), cela signifie que vous pouvez commander votre TreeSet en fonction du paramètre souhaité.
Nous pouvons dire qu'en passant un comparateur dans TreeSet, nous pouvons commander le TreeSet comme bon nous semble et ne pas utiliser l'ordre naturel utilisé par TreeSet.
Supposons que vous avez TreeSet<User> et que vous avez une classe User contenant le champ id.
Maintenant, si vous souhaitez trier votre TreeSet en fonction de l'ID utilisateur, vous pouvez transmettre un objet Comparateur dans votre TreeSet pour obtenir l'ordre souhaité.
TreeSet avec constructeur par défaut va trier l'élément dans un ordre croissant naturel, mais si vous souhaitez un tri personnalisé en fonction de vos besoins, vous devez utiliser l'interface de comparaison . Eq C'est votre classe par défaut Employee et vous souhaitez trier cette classe en fonction du salaire alors.
public class Employee {
private int Id;
private String name;
private int salary;
public Employee(int id, String name, int salary) {
super();
Id = id;
this.name = name;
this.salary = salary;
}
public int getId() {
return Id;
}
public void setId(int id) {
Id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public String toString() {
return "ID : "+Id +" Name : "+name+" Salary : "+salary+"\n";
}
}
Ici, nous avons créé une autre classe en implémentant Comparator.
public class EmpSalaryComparator implements Comparator{
public int compare(Object o1, Object o2) {
Employee e1=(Employee) o1;
Employee e2=(Employee) o2;
return e1.getSalary()-e2.getSalary();
}
}
public class Test1 {
public static void main(String[] args) {
TreeSet t1=new TreeSet(new EmpSalaryComparator());
Employee e1=new Employee(1001, "Ram", 1000);
Employee e2=new Employee(1002, "lucky", 7000);
Employee e3=new Employee(1003, "sumo", 3000);
Employee e4=new Employee(1004, "kharvi", 3000);
Employee e5=new Employee(1005, "priya", 1000);
t1.add(e1);
t1.add(e2);
t1.add(e3);
t1.add(e4);
t1.add(e5);
System.out.println(t1);
}
}