フィールドで並べ替える必要があるオブジェクトのリストがあります。たとえば、スコアです。あまり考えずに、Comparator を実装する新しいクラスを作成しました。これはタスクを実行し、機能します。
これを振り返ってみると、Comparator を実装する新しいクラスを作成する代わりに、クラスに Comparable を実装させるべきかどうか疑問に思っています。スコアは、オブジェクトが並べられる唯一のフィールドです。
私がやったことは実践として受け入れられるでしょうか？
「最初にクラスに Comparable を実装させ (自然な順序付けのために)、別のフィールド比較が必要な場合は、Comparator を実装する新しいクラスを作成する」という正しいアプローチはありますか?
上記の(2)が当てはまる場合、クラスに Comparable を実装させた後にのみ Comparator を実装する必要があるということですか? （私が元のクラスを所有していると仮定します）。
問題のオブジェクトのデフォルトComparableの (自然な) 順序付け動作を定義する場合に使用します。これには、オブジェクトの技術的または自然な (データベース?) 識別子を使用するのが一般的です。
外部の制御可能Comparatorな順序付け動作を定義する場合に使用します。これにより、デフォルトの順序付け動作をオーバーライドできます。
それがクラスをソートする明確で自然な方法である場合、オブジェクトは Comparable を実装する必要があり、クラスをソートする必要がある人は一般にそのようにしたいと思います。
ただし、並べ替えがクラスの通常とは異なる使用方法である場合、または並べ替えが特定のユース ケースでのみ意味をなす場合は、Comparator の方が適切なオプションです。
別の言い方をすれば、クラス名が与えられた場合、同等のものがどのようにソートされるかは明らかですか、それとも javadoc を読むことに頼る必要がありますか? 後者の場合、将来のすべてのソートのユースケースでコンパレータが必要になる可能性が高く、その時点で、コンパレートの実装はクラスのユーザーの速度を速めるのではなく、遅くする可能性があります。
使用Comparable：
使用Comparator：
Comparable。Comparableデフォルト（で指定される）の動作とは異なる動作を比較したい場合。同等-java.lang.Comparable: int compareTo(Object o1)
比較可能なオブジェクトは、自分自身を別のオブジェクトと比較できます。インスタンスを比較できるようにするには、クラス自体が java.lang.Comparable インターフェースを実装する必要があります。
only one sort sequenceで、インスタンスのプロパティに基づいて実装できます。元：Person.idコンパレータ-java.util.Comparator: int compare(Object o1, Object o2)
比較オブジェクトは、2 つの異なるオブジェクトを比較できます。クラスはそのインスタンスを比較していませんが、他のクラスのインスタンスを比較しています。このコンパレータ クラスは、java.util.Comparator インターフェースを実装する必要があります。
many sort sequenceで、インスタンスのプロパティに基づいて、それぞれを実装して名前を付けることができます。元：Person.id, Person.name, Person.age例：
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)
}
}
Java 8 Lambda : Comparatorについては、私の投稿を参照してください。
同じクラスのインスタンスを比較する場合は、Comparable を使用する必要があります。
Comparator を使用して、異なるクラスのインスタンスを比較できます。
Comparable は、オブジェクトの自然順序付けを定義する必要があるクラスによって実装されます。たとえば、String は Comparable を実装します。
異なるソート順が必要な場合は、コンパレータを実装し、2 つのインスタンスを比較する独自の方法を定義します。
Comparator は、Compariable が行うことすべてに加えて、さらに多くのことを行います。
| | 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
次のように、コンパレータを匿名クラスとして使用する最良の方法を見つけました。
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());
}
});
}
並べ替えを計画しているクラス内で、そのようなメソッドの複数のバージョンを作成できます。したがって、次のことができます。
sortAccountsByPriorityAndType
等...
これで、これらの並べ替えメソッドをどこでも使用して、コードを再利用できます。これにより、同等のすべての機能に加えて、さらに多くの機能が得られます...したがって、同等を使用する理由はまったくありません。
私はこう言います：
次の点は、どの状況で Comparable を使用し、どの Comparator で使用するかを決定するのに役立ちます。
1) コードの可用性
2) 単一のソート基準と複数のソート基準
3) Arays.sort() と Collection.sort()
4) SortedMap と SortedSet のキーとして
5) より多くのクラスと柔軟性
6) クラス間比較
7) 自然秩序
より詳細な記事については、いつ比較対象を使用し、いつ比較演算子を使用するかを参照できます
自然な順序の並べ替えが必要な場合-ユーザー比較可能カスタムの順序の並べ替えが必要な場合-コンパレータを使用
例：
Class Employee{
private int id;
private String name;
private String department;
}
自然な順序の並べ替えはidに基づいています。これは、一意であり、カスタムの順序の並べ替えは名前と部門であるためです。
参照：
クラスはいつComparableおよび/またはComparatorである必要がありますか？
http://javarevisited.blogspot.com/2011/06/comparator-and-comparable-in-java.html
ここに同様の質問がありました:クラスはいつ Comparable および/または Comparator になる必要がありますか?
私は次のように言います: 内部 ID に基づくなど、自然な順序付けのようなものに対して Comparable を実装します。
複数のフィールドなど、より複雑な比較アルゴリズムがある場合は、 Comparator を実装します。
Comparable:
同種の要素のみを保存し、デフォルトの自然な並べ替え順序が必要な場合はいつでも、 comparableインターフェイスを実装するクラスに行くことができます。
Comparator:
同種の要素と異種の要素を格納し、デフォルトのカスタマイズされた並べ替え順序で並べ替えたいときはいつでも、comparatorインターフェイスを使用できます。
あるインタビューで、特定の範囲の数値を nlogn 時間よりも早くソートするように求められました。(カウンティングソートは使用しません)
オブジェクトに Comparable インターフェイスを実装すると、暗黙的な並べ替えアルゴリズムで、オーバーライドされた compareTo メソッドを使用して並べ替え要素を並べ替えることができます。これは線形時間になります。
クラスを所有している場合は、Comparableを使用してください。一般に、クラスを所有していない場合はComparatorが使用されますが、Comparator は TreeSet または TreeMap のコンストラクターでパラメーターとして渡すことができるため、 TreeSetまたはTreeMapで使用する必要があります。Comparator と Comparable の使用方法は、 http://preciselyconcise.com/java/collections/g_comparator.phpで確認できます。
私の必要性は、日付に基づいてソートすることでした。
それで、私は Comparable を使用しましたが、それは私にとって簡単に機能しました。
public int compareTo(GoogleCalendarBean o) {
// TODO Auto-generated method stub
return eventdate.compareTo(o.getEventdate());
}
Comparable の制限の 1 つは、リスト以外のコレクションには使用できないことです。
非常に単純なアプローチは、問題のエンティティ クラスがデータベースで表され、データベース テーブルでエンティティ クラスのフィールドで構成されるインデックスが必要になると仮定することです。答えが「はい」の場合は、同等のものを実装し、自然な並べ替え順序のためにインデックス フィールドを使用します。それ以外の場合はすべてコンパレータを使用します。
Comparableとを実装するための私の注釈ライブラリComparator：
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);
}
}
リンクをクリックして、他の例を表示します。 http://code.google.com/p/compamatic/wiki/CompamaticByExamples