blocks|key|3274605|text|我会说，一个对象应该实现可比较，如果这是对类进行排序的明确自然的方法，并且任何需要对类进行排序的人通常都希望这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3274606|但是，如果排序是类的一种不寻常的使用，或者排序只对特定用例有意义，那么比较程序是更好的选择。|3274607|换句话说，给定类名，是否清楚可比较对象将如何排序，或者您是否必须读取javadoc？如果是后者，那么未来的每个排序用例都需要一个比较器，在这一点上，实现可比较可能会减慢类的用户，而不是加快他们的速度。|3274608|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I would say that an object should implement Comparable if that is the clear natural way to sort the class, and anyone would need to sort the class would generally want to do it that way.

If, however, the sorting was an unusual use of the class, or the sorting only makes sense for a specific use case, then a Comparator is a better option.

Put another way, given the class name, is it clear how a comparable would sort, or do you have to resort to reading the javadoc? If it is the latter, odds are every future sorting use case would require a comparator, at which point the implementation of comparable may slow down users of the class, not speed them up.

blocks|key|319028|text|使用Comparable如果您想定义相关对象的默认(自然)排序行为，通常的做法是使用技术或自然的(数据库？)此对象的对象的标识符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|319029|如果要定义外部可控排序行为，请使用Comparator，这可以覆盖默认的排序行为。|319030|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/lang/Comparable.html|1|http://java.sun.com/javase/6/docs/api/java/util/Comparator.html^0|2|A|N|2|2|A|0|0|5|4|H|A|H|A|1|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|D]]|E|@$9|X|A|Y|1|Z]]|F|$]]|$1|G|3|H|5|6|7|10|8|@$9|11|A|12|B|D]|$9|13|A|14|B|C]]|E|@$9|15|A|16|1|17]]|F|$]]|$1|I|3|-4|5|6|7|18|8|@]|E|@]|F|$]]]|J|$K|$5|L|M|N|F|$O|P]]|Q|$5|L|M|N|F|$O|R]]]]

Use <a href="http://java.sun.com/javase/6/docs/api/java/lang/Comparable.html" rel="noreferrer"><code>Comparable</code></a> if you want to define a default (natural) ordering behaviour of the object in question, a common practice is to use a technical or natural (database?) identifier of the object for this.

Use <a href="http://java.sun.com/javase/6/docs/api/java/util/Comparator.html" rel="noreferrer"><code>Comparator</code></a> if you want to define an external controllable ordering behaviour, this can override the default ordering behaviour.

blocks|key|3061355|text|使用Comparable|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3061356|如果对象在您的控制范围内，则为|3061357|。如果比较行为是主要比较行为，则为|unordered-list-item|3061358|。|3061359|3061360|使用Comparator：|3061361|3061362|如果对象不在您的控制范围之内，并且您不能让它们实现您想要的行为，则比较与默认(由Comparable指定)行为不同的行为。|3061363|3061364|entityMap^0|2|A|0|0|0|0|0|2|A|0|0|14|A|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Z|8|@]|D|@]|E|$]]|$1|K|3|L|5|J|7|10|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|15|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|19|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|U|$]]

Use <code>Comparable</code>:

<ul>
<li>if the object is in your control.</li>
<li>if the comparing behaviour is the main comparing behaviour.</li>
</ul>

Use <code>Comparator</code> :

<ul>
<li>if the object is outside your control and you cannot make them implement <code>Comparable</code>.</li>
<li>when you want comparing behaviour different from the default (which is specified by <code>Comparable</code>) behaviour.</li>
</ul>

blocks|key|3274812|text|+-+java.lang.Comparable:+int+compareTo(Object+o1)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3274813|可比较的对象能够将其自身与另一个对象进行比较。类本身必须实现java.lang.Comparable接口，以便能够比较其实例。|3274814|3274815|能够将当前对象与提供的对象进行比较。|unordered-list-item|3274816|通过使用它，我们可以基于实例属性来实现|3274817|。例如:字符串、包装类、日期、日历等预定义类的Person.id|3274818|Some实现了可比较的接口。|3274819|3274820|3274821|+-+java.util.Comparator:+int+compare(Object+o1,+Object+o2)|3274822|比较器对象能够比较两个不同的对象。该类不是比较它的实例，而是比较其他类的实例。这个比较器类必须实现java.util.Comparator接口。|3274823|3274824|能够比较任何两个相同类型的对象。|3274825|通过使用它，我们可以实现实例并根据实例属性为每个对象命名。例如：Person.id,+Person.name,+Person.age|3274826|We可以实现我们的预定义类的比较器接口，以进行自定义排序。|3274827|3274828|3274829|示例：|3274830|public+class+Employee+implements+Comparable<Employee>+{

++++private+int+id;
++++private+String+name;
++++private+int+age;
++++private+long+salary;

++++//+Many+sort+sequences+can+be+created+with+different+names.
++++public+static+Comparator<Employee>+NameComparator+=+new+Comparator<Employee>()+{+++++++++
++++++++@Override
++++++++public+int+compare(Employee+e1,+Employee+e2)+{
++++++++++++return+e1.getName().compareTo(e2.getName());
++++++++}
++++};
++++public+static+Comparator<Employee>+idComparator+=+new+Comparator<Employee>()+{+++++++
++++++++@Override
++++++++public+int+compare(Employee+e1,+Employee+e2)+{
++++++++++++return+Integer.valueOf(e1.getId()).compareTo(Integer.valueOf(e2.getId()));
++++++++}
++++};

++++public+Employee()+{+}
++++public+Employee(int+id,+String+name,+int+age,+long+salary){
++++++++this.id+=+id;
++++++++this.name+=+name;
++++++++this.age+=+age;
++++++++this.salary+=+salary;
++++}
++++//+setters+and+getters.

++++//+Only+one+sort+sequence+can+be+created+with+in+the+class.
++++@Override
++++public+int+compareTo(Employee+e)+{
++++//return+Integer.valueOf(this.id).compareTo(Integer.valueOf(e.id));
++++//return+Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
++++++++if+(this.id+>+e.id)+{
++++++++++++return+1;
++++++++}else+if(this.id+<+e.id){
++++++++++++return+-1;
++++++++}else+{
++++++++++++return+Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
++++++++}

++++}+++

++++public+static+void+main(String[]+args)+{

++++++++Employee+e1+=+new+Employee(5,+"Yash",+22,+1000);
++++++++Employee+e2+=+new+Employee(8,+"Tharun",+24,+25000);

++++++++List<Employee>+list+=+new+ArrayList<Employee>();
++++++++list.add(e1);
++++++++list.add(e2);
++++++++Collections.sort(list);+//+call+@compareTo(o1)
++++++++Collections.sort(list,+Employee.nameComparator);+//+call+@compare+(o1,o2)
++++++++Collections.sort(list,+Employee.idComparator);+//+call+@compare+(o1,o2)
++++}
}|code-block|syntax|javascript|3274831|对于自定义排序，我们使用@|3274832|(o1，o2)。对于其他场景，我们使用可比较的@compareTo(o1)，不需要更改代码，如果我们想对多个字段进行排序，则使用compare。|3274833|3274834|有关Java+8+Lambda+:+Comparator，请参阅我的帖子。|3274835|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/46075163/5081877^0|3|1A|0|0|0|0|0|N|9|0|0|0|0|3|1J|0|0|0|0|W|Y|0|0|0|0|0|0|0|0|0|2|Q|0|0^^$0|@$1|2|3|4|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1V|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|1X|8|@]|D|@]|E|$]]|$1|L|3|M|5|K|7|1Y|8|@]|D|@]|E|$]]|$1|N|3|O|5|K|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|K|7|22|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|23|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|24|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|25|8|@$9|26|A|27|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|28|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|29|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|K|7|2A|8|@]|D|@]|E|$]]|$1|10|3|11|5|K|7|2B|8|@$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|12|3|13|5|K|7|2E|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]|$1|15|3|-4|5|6|7|2G|8|@]|D|@]|E|$]]|$1|16|3|17|5|6|7|2H|8|@]|D|@]|E|$]]|$1|18|3|19|5|1A|7|2I|8|@]|D|@]|E|$1B|1C]]|$1|1D|3|1E|5|6|7|2J|8|@]|D|@]|E|$]]|$1|1F|3|1G|5|K|7|2K|8|@]|D|@]|E|$]]|$1|1H|3|-4|5|6|7|2L|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|2M|8|@]|D|@$9|2N|A|2O|1|2P]]|E|$]]|$1|1K|3|-4|5|6|7|2Q|8|@]|D|@]|E|$]]]|1L|$1M|$5|1N|1O|1P|E|$1Q|1R]]]]

<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Comparable.html" rel="noreferrer">Comparable</a> - <code>java.lang.Comparable: int compareTo(Object o1)</code>

A comparable object is capable of comparing itself with another object. The class itself must implements the java.lang.Comparable interface in order to be able to compare its instances.

<ul>
<li>Capable of comparing current object with the provided object.</li>
<li>By using this we can implement <code>only one sort sequence</code> based on the instances properties.
EX: <code>Person.id</code></li>
<li>Some of the Predefined Classes like String, Wrapper classes, Date, Calendar has implemented Comparable interface.</li>
</ul>

<hr>

<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Comparator.html" rel="noreferrer">Comparator</a> - <code>java.util.Comparator: int compare(Object o1, Object o2)</code>

A comparator object is capable of comparing two different objects. The class is not comparing its instances, but some other class’s instances. This comparator class must implement the java.util.Comparator interface.

<ul>
<li>Capable of comparing any two Objects of Same Type.</li>
<li>By using this we can implement <code>many sort sequence</code> and name each, based on the instances properties.
EX: <code>Person.id, Person.name, Person.age</code></li>
<li>We can implement Comparator interface to our Pre-defined classes for Customized sorting.</li>
</ul>

<hr>

Example:

<pre><code>public class Employee implements Comparable&lt;Employee&gt; {

 private int id;
 private String name;
 private int age;
 private long salary;

 // Many sort sequences can be created with different names.
 public static Comparator&lt;Employee&gt; NameComparator = new Comparator&lt;Employee&gt;() { 
 @Override
 public int compare(Employee e1, Employee e2) {
 return e1.getName().compareTo(e2.getName());
 }
 };
 public static Comparator&lt;Employee&gt; idComparator = new Comparator&lt;Employee&gt;() { 
 @Override
 public int compare(Employee e1, Employee e2) {
 return Integer.valueOf(e1.getId()).compareTo(Integer.valueOf(e2.getId()));
 }
 };

 public Employee() { }
 public Employee(int id, String name, int age, long salary){
 this.id = id;
 this.name = name;
 this.age = age;
 this.salary = salary;
 }
 // setters and getters.

 // Only one sort sequence can be created with in the class.
 @Override
 public int compareTo(Employee e) {
 //return Integer.valueOf(this.id).compareTo(Integer.valueOf(e.id));
 //return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
 if (this.id &gt; e.id) {
 return 1;
 }else if(this.id &lt; e.id){
 return -1;
 }else {
 return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
 }

 } 

 public static void main(String[] args) {

 Employee e1 = new Employee(5, "Yash", 22, 1000);
 Employee e2 = new Employee(8, "Tharun", 24, 25000);

 List&lt;Employee&gt; list = new ArrayList&lt;Employee&gt;();
 list.add(e1);
 list.add(e2);
 Collections.sort(list); // call @compareTo(o1)
 Collections.sort(list, Employee.nameComparator); // call @compare (o1,o2)
 Collections.sort(list, Employee.idComparator); // call @compare (o1,o2)
 }
}
</code></pre>

<ul>
<li>For customized sorting we go for comparator @compare(o1, o2) for other scenarios we go for comparable @compareTo(o1), with out changing code if we want to sort more than one field then we use comparator. </li>
</ul>

For <a href="https://stackoverflow.com/a/46075163/5081877">Java 8 Lambda : Comparator</a> refer to my post.

blocks|key|3061513|text|在比较相同类的实例时，应使用可比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3061514|比较器可用于比较不同类的实例。|3061515|比较是由需要为其对象定义自然排序的类实现的。例如，String实现了可比较的。|3061516|如果需要不同的排序顺序，则实现比较器并定义自己的方式来比较两个实例。|3061517|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Comparable should be used when you compare instances of the same class.
Comparator can be used to compare instances of different classes.
Comparable is implemented by the class which needs to define a natural ordering for its objects.
For example, String implements Comparable.
In case a different sorting order is required, then, implement comparator and define its own way of comparing two instances.

blocks|key|316335|text|如果对象的排序需要基于自然顺序，则使用，而如果需要对不同对象的属性进行排序，则使用Java.|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|316336|比较器和比较器的主要区别：|316337|%2B------------------------------------------------------------------------------------%2B
¦+++++++++++++++Comparable++++++++++++++++¦++++++++++++++++Comparator++++++++++++++++¦
¦-----------------------------------------%2B------------------------------------------¦
¦+java.lang.Comparable++++++++++++++++++++¦+java.util.Comparator+++++++++++++++++++++¦
¦-----------------------------------------%2B------------------------------------------¦
¦+int+objOne.compareTo(objTwo)++++++++++++¦+int+compare(objOne,+objTwo)++++++++++++++¦
¦-----------------------------------------%2B------------------------------------------¦
¦+Negative,+if+objOne+<+objTwo++++++++++++¦+Same+as+Comparable+++++++++++++++++++++++¦
¦+Zero,++if+objOne+==+objTwo++++++++++++++¦++++++++++++++++++++++++++++++++++++++++++¦
¦+Positive,++if+objOne+>+objTwo+++++++++++¦++++++++++++++++++++++++++++++++++++++++++¦
¦-----------------------------------------%2B------------------------------------------¦
¦+You+must+modify+the+class+whose+++++++++¦+You+build+a+class+separate+from+to+sort.+¦
¦+instances+you+want+to+sort.+++++++++++++¦+the+class+whose+instances+you+want+++++++¦
¦-----------------------------------------%2B------------------------------------------¦
¦+Only+one+sort+sequence+can+be+created+++¦+Many+sort+sequences+can+be+created+++++++¦
¦-----------------------------------------%2B------------------------------------------¦
¦+Implemented+frequently+in+the+API+by:+++¦+Meant+to+be+implemented+to+sort++++++++++¦
¦+String,+Wrapper+classes,+Date,+Calendar+¦+instances+of+third-party+classes.++++++++¦
%2B------------------------------------------------------------------------------------%2B|code-block|syntax|javascript|316338|entityMap^0|J|R|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

If sorting of objects needs to be based on natural order then use Comparable whereas if your sorting needs to be done on attributes of different objects, then use Comparator in Java.
Main differences between Comparable and Comparator:
<pre><code>+------------------------------------------------------------------------------------+
¦ Comparable ¦ Comparator ¦
¦-----------------------------------------+------------------------------------------¦
¦ java.lang.Comparable ¦ java.util.Comparator ¦
¦-----------------------------------------+------------------------------------------¦
¦ int objOne.compareTo(objTwo) ¦ int compare(objOne, objTwo) ¦
¦-----------------------------------------+------------------------------------------¦
¦ Negative, if objOne &lt; objTwo ¦ Same as Comparable ¦
¦ Zero, if objOne == objTwo ¦ ¦
¦ Positive, if objOne &gt; objTwo ¦ ¦
¦-----------------------------------------+------------------------------------------¦
¦ You must modify the class whose ¦ You build a class separate from to sort. ¦
¦ instances you want to sort. ¦ the class whose instances you want ¦
¦-----------------------------------------+------------------------------------------¦
¦ Only one sort sequence can be created ¦ Many sort sequences can be created ¦
¦-----------------------------------------+------------------------------------------¦
¦ Implemented frequently in the API by: ¦ Meant to be implemented to sort ¦
¦ String, Wrapper classes, Date, Calendar ¦ instances of third-party classes. ¦
+------------------------------------------------------------------------------------+
</code></pre>

blocks|key|3061634|text|比较器做了comparable做的所有事情，再加上更多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3061635|3061636|+%7C++++++++++++++++++++++++++++++++++++++++++++++++++++++++%7C+Comparable+%7C+Comparator+++._______________________________________________________________________________+++Is+used+to+allow+Collections.sort+to+work+++++++++++++++%7C+yes++++++++%7C+++yes+++Can+compare+multiple+fields+++++++++++++++++++++++++++++%7C+yes++++++++%7C+++yes+++Lives+inside+the+class+you’re+comparing+and+serves++++++%7C++++++++++++%7C+++as+a+“default”+way+to+compare+++++++++++++++++++++++++++%7C+yes++++++++%7C+++yes+++Can+live+outside+the+class+you’re+comparing+++++++++++++%7C+no+++++++++%7C+++yes+++Can+have+multiple+instances+with+different+method+names+%7C+no+++++++++%7C+++yes+++Input+arguments+can+be+a+list+of++++++++++++++++++++++++%7C+just+Object%7C+++Any+type+++Can+use+enums+++++++++++++++++++++++++++++++++++++++++++%7C+no+++++++++%7C+++yes+|blockquote|offset|length|style|CODE|3061637|3061638|我发现使用比较器作为匿名类的最佳方法如下：|3061639|private+static+void+sortAccountsByPriority(List<AccountRecord>+accounts)+{
++++Collections.sort(accounts,+new+Comparator<AccountRecord>()+{

++++++++@Override
++++++++public+int+compare(AccountRecord+a1,+AccountRecord+a2)+{
++++++++++++return+a1.getRank().compareTo(a2.getRank());
++++++++}
++++});
}|code-block|syntax|javascript|3061640|您可以在计划排序的类中创建此类方法的多个版本。因此，您可以拥有：|3061641|3061642|sortAccountsByPriority+|unordered-list-item|3061643|sortAccountsByType|3061644|sortAccountsByPriorityAndType|3061645|3061646|等等...|3061647|现在，您可以在任何地方使用这些排序方法，并获得代码重用。这给了我所有类似的东西，再加上更多...所以我根本看不到任何使用可比较的理由。|3061648|entityMap^0|0|0|1|M4|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1A|8|@$F|1B|G|1C|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1E|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1F|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|1G|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|1I|8|@]|9|@]|A|$]]|$1|X|3|Y|5|W|7|1J|8|@]|9|@]|A|$]]|$1|Z|3|10|5|W|7|1K|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1M|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1N|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|17|$]]

Comparator does everything that comparable does, plus more.

<blockquote>
 <code>| | Comparable | Comparator
 ._______________________________________________________________________________
 Is used to allow Collections.sort to work | yes | yes
 Can compare multiple fields | yes | yes
 Lives inside the class you’re comparing and serves | |
 as a “default” way to compare | yes | yes
 Can live outside the class you’re comparing | no | yes
 Can have multiple instances with different method names | no | yes
 Input arguments can be a list of | just Object| Any type
 Can use enums | no | yes
 </code>
</blockquote>

I found the best approach to use comparators as anonymous classes as follows:

<pre><code>private static void sortAccountsByPriority(List&lt;AccountRecord&gt; accounts) {
 Collections.sort(accounts, new Comparator&lt;AccountRecord&gt;() {

 @Override
 public int compare(AccountRecord a1, AccountRecord a2) {
 return a1.getRank().compareTo(a2.getRank());
 }
 });
}
</code></pre>

You can create multiple versions of such methods right inside the class you’re planning to sort. So you can have:

<ul>
<li>sortAccountsByPriority </li>
<li>sortAccountsByType</li>
<li>sortAccountsByPriorityAndType 

etc...</li>
</ul>

Now, you can use these sort methods anywhere and get code reuse.
This gives me everything a comparable would, plus more ... so I don’t see any reason to use comparable at all.

blocks|key|3061425|text|我会说：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3061426|3061427|如果比较是直观的，那么一定要实现可比较代码如果不清楚您的比较是否是直观的，请使用比较程序，因为它更明确，因此对于必须维护代码的可怜的人来说更清楚。|unordered-list-item|3061428|如果可能有多个直观比较，我更喜欢比较程序，可能是由要比较的类中的工厂方法构建的。|3061429|如果比较是特殊目的，请使用比较程序|3061430|<代码>F29>|3061431|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|O|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

I would say:

<ul>
<li>if the comparison is intuitive, then by all means implement Comparable</li>
<li>if it is unclear wether your comparison is intuitive, use a Comparator as it's more
explicit and thus more clear for the poor soul who has to maintain the code</li>
<li>if there is more than one intuitive comparison possible I'd prefer a Comparator,
possibly build by a factory method in the class to be compared.</li>
<li>if the comparison is special purpose, use Comparator</li>
</ul>

blocks|key|319225|text|以下几点有助于您决定在哪些情况下应该使用比较程序以及在哪个比较程序中使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|319226|1)代码可用性|319227|2)单个排序条件与多个排序条件|319228|3)+Arays.sort()和Collection.sort()|319229|4)作为SortedMap和SortedSet中的键|319230|5)更多的类数量而不是灵活性|319231|6)类间比较|319232|7)自然顺序|319233|有关更详细的文章，请参阅When+to+use+comparable+and+when+to+use+comparator|offset|length|319234|entityMap|0|LINK|mutability|MUTABLE|url|http://java-journal.blogspot.in/2011/01/when-to-use-comparable-and-when-to-use.html^0|0|0|0|0|0|0|0|0|C|1D|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@$R|1A|S|1B|1|1C]]|A|$]]|$1|T|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

The following points help you in deciding in which situations one should use Comparable and in which Comparator:

1) Code Availabilty

2) Single Versus Multiple Sorting Criteria

3) Arays.sort() and Collection.sort()

4) As keys in SortedMap and SortedSet

5) More Number of classes Versus flexibility

6) Interclass comparisions

7) Natural Order

For more detailed article you can refer <a href="http://java-journal.blogspot.in/2011/01/when-to-use-comparable-and-when-to-use.html" rel="noreferrer">When to use comparable and when to use comparator</a>

blocks|key|317236|text|如果你需要自然排序--用户比较如果你需要自定义排序-使用比较器|type|unstyled|depth|inlineStyleRanges|entityRanges|data|317237|示例：|317238|Class+Employee{
private+int+id;
private+String+name;
private+String+department;
}|code-block|syntax|javascript|317239|自然顺序排序将基于id，因为它将是唯一的，并且自定义顺序排序将是名称和部门。|317240|参考：|317241|When+should+a+class+be+Comparable+and/or+Comparator?+http://javarevisited.blogspot.com/2011/06/comparator-and-comparable-in-java.html|offset|length|317242|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1440134/java-what-is-the-difference-between-implementing-comparable-and-comparator|1|http://javarevisited.blogspot.com/2011/06/comparator-and-comparable-in-java.html^0|0|0|0|0|0|0|1G|0|1H|28|1|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@$O|16|P|17|1|18]|$O|19|P|1A|1|1B]]|A|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]]]

If you need natural order sorting -- User Comparable
IF you need Custom Order Sorting - Use Comparator

Example:

<pre><code>Class Employee{
private int id;
private String name;
private String department;
}
</code></pre>

Natural order Sorting would be based on id because it would be unique and custom order sortin g would be name and department.

Refrences: 
<a href="https://stackoverflow.com/questions/1440134/java-what-is-the-difference-between-implementing-comparable-and-comparator">When should a class be Comparable and/or Comparator?</a> 
<a href="http://javarevisited.blogspot.com/2011/06/comparator-and-comparable-in-java.html" rel="nofollow noreferrer">http://javarevisited.blogspot.com/2011/06/comparator-and-comparable-in-java.html</a>

blocks|key|319100|text|如果在编写这个类的时候，你只有一个排序的用例，使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|319101|。|unordered-list-item|319102|仅当您有多个排序策略时才实现比较器。|319103|319104|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|L|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

<ul>
<li>If at the moment of writing the class
you have only one use case of sorting
use Comparable. </li>
<li>Only when you have more than one
strategy of sorting implement a
Comparator.</li>
</ul>

blocks|key|3061262|text|这里有一个类似的问题：When+should+a+class+be+Comparable+and/or+Comparator?|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3061263|我要说的是:实现类似于自然排序的东西，例如基于内部ID|3061264|如果你有一个更复杂的比较算法，比如多个字段等等，实现一个比较器。|3061265|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1440134/java-what-is-the-difference-between-implementing-comparable-and-comparator^0|B|1G|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

There had been a similar question here: <a href="https://stackoverflow.com/questions/1440134/java-what-is-the-difference-between-implementing-comparable-and-comparator">When should a class be Comparable and/or Comparator?</a>

I would say the following:
Implement Comparable for something like a natural ordering, e.g. based on an internal ID

Implement a Comparator if you have a more complex comparing algorithm, e.g. multiple fields and so on.

blocks|key|3274775|text|可比较的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3274776|当我们只想存储同构元素和默认的自然排序顺序时，我们可以选择实现comparable接口的类。|CODE|3274777|比较器：|3274778|每当我们想要存储同构和异构元素，并且想要按默认的自定义排序顺序进行排序时，我们都可以使用comparator接口。|3274779|entityMap^0|4|1|0|V|A|0|0|4|0|18|A|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|K|3|L|5|6|7|X|8|@$9|Y|A|Z|B|H]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|N|$]]

Comparable: 
 Whenever we want to store only homogeneous elements and default natural sorting order required, we can go for class implementing <code>comparable</code> interface.

Comparator: 
Whenever we want to store homogeneous and heterogeneous elements and we want to sort in default customized sorting order, we can go for <code>comparator</code> interface.

blocks|key|3061620|text|我的需求是基于日期进行排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3061621|因此，我使用了可比较的，它对我来说很容易工作。|3061622|public+int+compareTo(GoogleCalendarBean+o)+{
++++//+TODO+Auto-generated+method+stub
++++return+eventdate.compareTo(o.getEventdate());
}|code-block|syntax|javascript|3061623|使用可比较的一个限制是它们不能用于列表以外的集合。|3061624|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

My need was sort based on date.

So, I used Comparable and it worked easily for me.

<pre><code>public int compareTo(GoogleCalendarBean o) {
 // TODO Auto-generated method stub
 return eventdate.compareTo(o.getEventdate());
}
</code></pre>

One restriction with Comparable is that they cannot used for Collections other than List.

blocks|key|316255|text|如果你拥有这个类，最好使用可比的。通常，如果您不拥有这个类，则可以使用比较器，但您必须使用它作为+TreeSet+或+TreeMap+，因为可以将比较器作为参数传递到TreeSet或TreeMap的构造器中。您可以看到如何在http://preciselyconcise.com/java/collections/g_comparator.php中使用比较函数和可比较函数|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|316256|entityMap|0|LINK|mutability|MUTABLE|url|http://preciselyconcise.com/java/collections/g_comparator.php^0|D|3|Z|3|1C|9|1M|9|34|1P|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]]|E|$]]|$1|F|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

If you own the class better go with Comparable. Generally Comparator is used if you dont own the class but you have to use it a TreeSet or TreeMap because Comparator can be passed as a parameter in the conctructor of TreeSet or TreeMap. You can see how to use Comparator and Comparable in <a href="http://preciselyconcise.com/java/collections/g_comparator.php" rel="nofollow">http://preciselyconcise.com/java/collections/g_comparator.php</a>

blocks|key|3061657|text|在一次面试中，我被要求在比nlogn时间更短的时间内对一定范围的数字进行排序。(不使用计数排序)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3061658|在对象上实现可比较接口允许隐式排序算法使用覆盖的compareTo方法对排序元素进行排序，这将是线性时间。|3061659|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I have been asked sorting of a definite range of numbers in better than nlogn time in one of interview. (Not using Counting sort)

Implementing Comparable interface over an object allows implicit sorting algos to use overridden compareTo method to order sort elements and that would be linear time.

blocks|key|3274917|text|比较是默认的自然排序顺序，为数值提供升序，为字符串提供字母顺序。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3274918|Treeset+t=new+Treeset();
t.add(2);
t.add(1);
System.out.println(t);//[1,2]|code-block|syntax|javascript|3274919|比较器是在自定义myComparator类中通过覆盖compare方法实现的自定义排序顺序，例如：|3274920|Treeset+t=new+Treeset(new+myComparator());
t.add(55);
t.add(56);
class+myComparator+implements+Comparator{
public+int+compare(Object+o1,Object+o2){
//Descending+Logic
}
}
System.out.println(t);//[56,55]|3274921|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Comparable is the default natural sorting order provided for numerical values are ascending and for strings are alphabetical order.
for eg:

<pre><code>Treeset t=new Treeset();
t.add(2);
t.add(1);
System.out.println(t);//[1,2]
</code></pre>

Comparator is the custom sorting order implemented in custom myComparator class by overriding a compare method
for eg:

<pre><code>Treeset t=new Treeset(new myComparator());
t.add(55);
t.add(56);
class myComparator implements Comparator{
public int compare(Object o1,Object o2){
//Descending Logic
}
}
System.out.println(t);//[56,55]
</code></pre>

blocks|key|314171|text|非常简单的方法是假设所讨论的实体类在数据库中表示，然后在数据库表中，您是否需要由实体类的字段组成的索引？如果答案是yes，则实现比较并使用索引字段进行自然排序。在所有其他情况下，使用比较器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|314172|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Very simple approach is to assume that the entity class in question be represented in database and then in database table would you need index made up of fields of entity class? If answer is yes then implement comparable and use the index field(s) for natural sorting order. In all other cases use comparator.

blocks|key|317252|text|我用于实现Comparable和Comparator的注释库|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|317253|public+class+Person+implements+Comparable<Person>+{+++++++++
++++private+String+firstName;++
++++private+String+lastName;+++++++++
++++private+int+age;+++++++++
++++private+char+gentle;+++++++++

++++@Override+++++++++
++++@CompaProperties({+@CompaProperty(property+=+"lastName"),++++++++++++++
++++++++@CompaProperty(property+=+"age",++order+=+Order.DSC)+})+++++++++++
++++public+int+compareTo(Person+person)+{+++++++++++++++++
++++++++return+Compamatic.doComparasion(this,+person);+++++++++
++++}++
}|code-block|syntax|javascript|317254|单击该链接可查看更多示例。http://code.google.com/p/compamatic/wiki/CompamaticByExamples|317255|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/compamatic/wiki/CompamaticByExamples^0|5|A|G|A|0|0|D|1P|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

My annotation lib for implementing <code>Comparable</code> and <code>Comparator</code>:

<pre><code>public class Person implements Comparable&lt;Person&gt; { 
 private String firstName; 
 private String lastName; 
 private int age; 
 private char gentle; 

 @Override 
 @CompaProperties({ @CompaProperty(property = "lastName"), 
 @CompaProperty(property = "age", order = Order.DSC) }) 
 public int compareTo(Person person) { 
 return Compamatic.doComparasion(this, person); 
 } 
}
</code></pre>

Click the link to see more examples.
<a href="http://code.google.com/p/compamatic/wiki/CompamaticByExamples" rel="nofollow">http://code.google.com/p/compamatic/wiki/CompamaticByExamples</a>

I have a list of objects I need to sort on a field, say Score. Without giving much thought I wrote a new class that implements Comparator, that does the task and it works. 

Now looking back at this, I am wondering if I should have instead have the my class implement Comparable instead of creating a new class that implements Comparator. The score is the only field that the objects will be ordered on. 

<ol>
<li>What I have done acceptable as a practice? </li>
<li>Is the right approach "First have the class implement Comparable (for the natural ordering) and if an alternative field comparison is required, then create a new class that implements Comparator" ?</li>
<li>If (2) above is true, then does it mean that one should implement Comparator only after they have the class implement Comparable? (Assuming I own the original class).</li>
</ol>

When to use Comparable and Comparator

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我有一个需要对字段进行排序的对象列表，比如Score。我不假思索地写了一个新的类，实现了比较器，它完成了这个任务，并且它工作了。现在回过头来看，我想知道我是否应该让我的类实现可比较，而不是创建一个实现比较器的新类。分数是对对象进行排序的唯一字段。是正确的方法“首先让类实现可比较的(对于自然排序)，如果需要可选的字段比较，然后创建一个实现比较器的新类”？如果上面的(2)是真的，那么是否意味着只有在让

问何时使用比较和比较器
EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问何时使用比较和比较器EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问何时使用比较和比较器
EN