答案：

Question

我当时正在研究Java的集合，在这期间，我陷入了比较器的困境。在下面的代码中：

class MyComp implements Comparator<String> {
    public int compare(String a, String b) {
        String aStr, bStr;
        aStr = a;
        bStr = b;
        // Reverse the comparison.
        return bStr.compareTo(aStr);
       }
       // No need to override equals.
      }
class CompDemo {
    public static void main(String args[]) {
    // Create a tree set.
    TreeSet<String> ts = new TreeSet<String>(new MyComp());
    // Add elements to the tree set.
    ts.add("C");
    ts.add("A");
    ts.add("B");
    ts.add("E");
    ts.add("F");
    ts.add("D");
    // Display the elements.
    for(String element : ts)
    System.out.print(element + " ");
    System.out.println();
   }
  }

我无法理解第2行的public int compare(String a, String b)是否被覆盖？另外，TreeSet<String> ts = new TreeSet<String>(new MyComp())行是什么意思？
我读到了

Comparator接口定义了两种方法：compare（）和equals（）。

然后使用 compareTo（）。

元素如何反转？

如果有人对我在上文中描述的任何问题都有答案，请继续。

Answer 1

树集是一个排序集，即它对树集内的元素进行排序。现在，它如何排序？它使用比较器。即在代码中的某处使用它进行比较。

    int cmp;
    Entry<K,V> parent;
    // split comparator and comparable paths
    Comparator<? super K> cpr = comparator;
    if (cpr != null) {
        do {
            parent = t;
            cmp = cpr.compare(key, t.key);
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else
                return t.setValue(value);
        } while (t != null);
    }

这来自TreeSet源代码。

Answer 2

compare（a，b）的工作方式如下：

如果a“小于” b，则返回一个负整数。如果“等于”，则返回0。如果a“大于” b，则返回一个正整数。

根据比较器类型，应定义“小于”，“等于”和“大于”的含义。

示例：

public class Person {
private int id;
private String name;

public Person(int id, String name) {
    this.id = id;
    this.name = name;
}

public int getId() {
    return id;
}

public String getName() {
    return name;
}}

public class PersonComparator implements Comparator<Person> {
@Override public int compare(Person o1, Person o2) {
    if(o1.getId() == o2.getId()) return 0;
    else if(o1.getId() < o2.getId()) return -1;
    else return 1;
    // can be replaced by Integer.compare
}}

希望这会有所帮助。

Answer 3

让我们一一开始，比较器是一种比较某些通用类型的对象的方法

通常，Comparator可以处理Java包装器[Integer，Double，Character ...]，但是有时当涉及到更复杂形式的对象时，它根本不适合例如，假设我们有一个名为“时间”的对象，它的时间（小时，分钟，秒）为我们想对这些对象进行排序，但是在这里我们不能使用默认的compare(T a, T b)，因为我们说它可以处理特定类别的对象这是我们必须实现比较器接口并与可以处理我们的情况进行比较的部分例如，对于时间对象，我们可以按以下方式进行操作，以便对这些对象进行排序：

 public class TimeComparator implements Comparator<Time2> {
    @Override
    public int compare(Time2 time1, Time2 time2) {
        int hourDifference = time1.getHour() - time2.getHour();

        if (hourDifference != 0) { // test the hour first
            return hourDifference;
        }

        int minuteDifference = time1.getMinute() - time2.getMinute();

        if (minuteDifference != 0) { // then test the minute
            return minuteDifference;
        }

        int secondDifference = time1.getSecond() - time2.getSecond();
        return secondDifference;
    }

}

然后如何使用compareTo（）。

compareTo是Comparable类中存在的一种方法，可以采用一种不同的方式使用，因为它采用一个通用类型并将其与您引用的值进行比较（不确定这是否是描述它的正确方法）

a.compareTo(T b)

TreeSet ts = new TreeSet（new MyComp（））;

TreeSet是没有重复项的有序集合，当未提供时使用默认的Comparator泛型如您在TreeSet构造函数javadocs

中所见

TreeSet(Comparator<? super E> comparator)
Constructs a new, empty tree set, sorted according to the specified comparator.

这意味着您的TreeSet将根据您提供的任何比较器（而不是默认实现的比较器）进行排序

比较器还用作使用Collections.sort静态方法的简便方法

sort(List<T> list, Comparator<? super T> c)
Sorts the specified list according to the order induced by the specified comparator.

Answer 4

字符串类实现可比的接口

包装器类同时实现可比较器和比较器

比较器使排序逻辑与我们定义的类分离。可比对象绑定到该类，我们只能在一个字段上执行排序。

答案：

比较发生在字符之间（字符串是字符组）或数字之间

当实现compare方法时，如果要比较2个字符串，则必须调用compareTo（..）方法（该compareTo（）方法实现为比较每个字符.i，e例如：String name1 = sam，String name2 = joe，如果您调用name1.compareTo（name2），则将s与j进行比较，将a与o进行比较，将m与e进行比较。由于s不等于j，因此不会继续进行进一步的比较并返回-ve值bcz s的ascii值小于j的ascii值。

如果要比较2个数字，则可以直接将其与'=='进行比较，也可以通过包装调用compareTo（..）。并根据比较结果返回+ ve，-ve或0。

像这样的比较一直持续到比较所有元素为止。

每次将元素添加到树或任何集合中时，都会进行比较并保持排序，直到所有元素添加并完成。

Object类中提供了

equals（）方法，因此您无需实现它。默认情况下将继承。

比较器如何工作？

4 个答案:

答案：