比较者在哪些方面优于可比者？

Question

“如何根据员工对象的id或名称对集合进行排序”。为此，我们可以使用两个接口，即comparator和carparable。这似乎是常见的面试问题之一

但是我看不出为什么我应该同时使用这两个来对employee对象进行排序

我一直在思考comparator实现了carparate无法实现的功能。我明白，如果对象（所比较的实例变量）具有自然顺序，那么carable是正确的选择。但是，如果需要自定义排序（例如字符串长度），那么可以编写比较器。这里我的观点是，comparator只有当客户机希望按照其他条件对数据进行排序时才需要。例如，我将实现一个Employee类，使用carable interface按ID排序。但是，如果客户机希望按字符串(name)对Employee对象进行排序，他将实现comparator作为具体类或匿名排序。我这里有什么遗漏吗？

(The commented-out parts of the code works. They are just different implementations)

mport java.util.Collections;
import java.util.Comparator;
import java.util.*;

public class PersonComparator implements Comparable{
    private String name;
    private int age;

    public PersonComparator(String name, int age) {
        this.name = name;
        this.age = age;
    }
@Override
public String toString() {
    return "name=" + name + ", age=" + age;
}

/*@Override
public int compareTo(Object obj) {
    if (!(obj instanceof PersonComparator)) {
        throw new ClassCastException("Invalid object");
    }
    PersonComparator p2 = (PersonComparator)obj;
    return this.age-p2.age;
}*/

/*Alternative CompareTo that checks for both age and name*/
 public int compareTo(Object obj) {
    if (!(obj instanceof PersonComparator)) {
        throw new ClassCastException("Invalid object");
    }
    PersonComparator p2 = (PersonComparator)obj;
    if (this.age!=p2.age){
        return this.age-p2.age;
    }
    else {
    return (this.name.length()-p2.name.length());
}
} 


/*public static Comparator nameLengthComparator 
= new Comparator() {


    @Override
    public int compare(Object obj1, Object obj2) {
        if (!(obj1 instanceof PersonComparator) || !(obj2 instanceof PersonComparator)){
            throw new ClassCastException("Invalid object");
        }
        else {
            PersonComparator p1 = (PersonComparator)obj1;
            PersonComparator p2 = (PersonComparator)obj2;
            return p1.name.length()-p2.name.length();
        }
}
};*/

 public static void main(String[] args){
     PersonComparator p1 = new PersonComparator("Alexander", 45);
     PersonComparator p2 = new PersonComparator("Pat", 27);
     PersonComparator p3 = new PersonComparator("Zacky", 45);
     PersonComparator p4 = new PersonComparator("Rake", 34);

     List<PersonComparator> list = new ArrayList<PersonComparator>();
     list.add(p1);
     list.add(p2);
     list.add(p3);
     list.add(p4);

     System.out.println("Before sorting "+ list);
     Collections.sort(list);
     //System.out.println("After sorting by age "+ list);
     //System.out.println("Before sorting "+ list);
     //Collections.sort(list, nameLengthComparator);
     System.out.println("After sorting by name length "+ list);
     /*Collections.sort(list, new Comparator<PersonComparator>() {
         @Override
            public int compare(PersonComparator p1, PersonComparator p2) {
                    return p1.name.length()-p2.name.length();
                }
        }
    );*/
     System.out.println("After sorting by name length "+ list);
 }

}

Answer 1

carable接口定义类型的自然顺序。假设您有一个string或integer对象列表；您可以将该列表传递给

Collections.sort(list);

你会有一个排序的列表。怎么做？因为string和integer都实现了carable接口，而carable接口的实现提供了自然的顺序。这就像类定义所说的那样--“如果您发现了一个属于我的类型的对象集合，请按照我在compareto方法中定义的策略对它们进行排序”。

现在，当您定义自己的类型时，您可以通过实现carable接口来定义类对象的自然顺序。有关对象排序的更多信息，请参见Java文档。

comparator接口描述如何定义对象排序的自定义策略。假设我们有一个简单的person类型，如下所示：

public class Person {
    String name;

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

    public String getName() {
        return name;
    }
}

现在，通过实现comparator接口，您可以编写不同的策略来排序person类型的实例。例如，考虑下面给出的对Person对象进行排序的两种策略：

class StrategyOne implements Comparator<Person> {

    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().length() - p2.getName().length();
    }

}

class StrategyTwo implements Comparator<Person> {

    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }

}

在这里，StrategyOne将根据名称的长度对Person对象进行排序，StrategyTwo将根据名称的词典顺序对Person对象进行排序。

class Strategies {
    private static final Comparator<Person> PERSON_NAME_LENGTH_COMPARATOR = new StrategyOne();

    private static final Comparator<Person> PERSON_NAME_LEXICAL_COMPARATOR = new StrategyTwo();

    public static Comparator<Person> personNameLengthComparator(){
         return  PERSON_NAME_LENGTH_COMPARATOR;
    }


    public static Comparator<Person> personNameLexicalComparator(){
         return  PERSON_NAME_LEXICAL_COMPARATOR;
    }
}