Java 带比较器的树集构造函数<&燃气轮机；参数

在其中一个构造函数中，显示了以下标题：

TreeSet(Comparator<? super E> c)

---

TreeSet（比较器树集中的元素保持排序

如果使用没有比较器的构造函数，则元素类的自然顺序（由
Comparable
的实现定义）将用于对树集的元素进行排序

如果需要不同的排序，可以在构造函数中提供一个比较器。
它用于根据用户定义的规则对集合的元素进行排序

见：

公共树集（比较器比较器）
构建新的,，
空树集，根据指定的比较器排序

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);
}
}

全部
插入到集合中的元素必须由
指定的比较器：比较器。比较（e1，e2）不能抛出
集合中任何元素e1和e2的ClassCastException

如果用户
尝试向集合中添加违反此约束的元素，
add调用将抛出ClassCastException

参数：

比较器-
将用于对此集合排序的比较器。如果为null，则
将使用元素的自然顺序

有关自然对象排序的更多信息，请参阅。
比较器接口用于对用户定义类的对象进行排序。

它提供了多个排序顺序，即您可以根据任何数据成员对元素进行排序。例如，它可以是rollno、name、age或其他任何内容

通过在
TreeSet（Comparator中传递一个比较器，此构造函数允许您定义
比较器
，当将
T
插入
集合
后面的树中时使用该比较器

Comparator<String> comp = (String o1, String o2) -> (o1.compareTo(o2));
Set<String> ts = new TreeSet<>(comp);

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();
  }
}

比较器comp=（字符串o1，字符串o2）->（o1.compareTo（o2））；
设置ts=新树集（comp）；
A
TreeSet
是A，它基于给定两个元素A和b的概念，即A是否“小于”b。但是，如果您定义自己的类，TreeSet
不知道如何确定该类的给定对象是否“小于”另一个对象，因为它无法知道您对对象内容的预期解释。因此，您可以创建一个
比较器
，它可以代表
树集进行比较
以下代码显示了如何使用树集.TreeSet（ComparatorTreeset类具有以下构造函数，以便Treeset按照比较器c描述的顺序使用存储元素。下面是一个示例来说明相同的情况

Comparator<String> comp = (String o1, String o2) -> (o1.compareTo(o2));
Set<String> ts = new TreeSet<>(comp);

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();
  }
}

    **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());
                }
            }
        }

**构造函数：-**
TreeSet（Comparator带有默认构造函数的TreeSet将按自然升序对元素进行排序，但是如果您希望根据您的需求进行一些自定义排序，那么您应该使用Comparator接口。
情商
这是您的默认类别员工，您希望根据薪资对该类别进行排序

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";
}
}

在这里，我们通过实现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);
}
}

以上所有答案都是正确的，但我想补充一点，自定义比较器除了产生不同的排序外，还将以不同的方式过滤值

由于集合的值是单音的，如果自定义比较器返回两个值相同，则集合中将只显示其中一个值：

    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 "]

Set s=新树集（新比较器（）{
@凌驾
公共整数比较（字符串s1、字符串s2）{
返回s1.trim（）.compareTo（s2.trim（））；
}
});
s、 添加（“1”）；
s、 添加（“1”）；
s、 添加（“2”）；
s、 添加（“2”）；
s、 添加（“2”）；
Arrays.toString（s.toArray（））；//[“1”，“2”]
您也可以将Lambda与Java8一起使用

Set<T> s = new TreeSet<>((a, b) -> func(a) - func(b));

Set s=newtreeset（（a，b）->func（a）-func（b））；
[ID:1001姓名：Ram薪资：1000，ID:1003姓名：相扑薪资：3000，ID:1002姓名：幸运薪资：7000]
这是上述代码的输出。我不明白为什么。可能是因为
比较
方法在相同工资的情况下返回
0
。我有这个问题已经2个小时了。我希望TreeSet使用hashset或equal函数来确定是否存在。（包含）所以我希望它会出现在所有项目上。实际上，它们并不相等，应该按不同的顺序添加。对象不同，但它们的排序结果相同。我希望看到这一点。看起来这种方法不正确