回答:
オブジェクトの注文に関するチュートリアルは次のとおりです。
いくつか例を挙げますが、とにかく読むことをお勧めします。
をソートするにはさまざまな方法がありますArrayList。自然な（デフォルトの）順序を定義したい場合は、Contact実装を許可する必要がありますComparable。デフォルトでnameでソートしたい場合、次のようにします（簡単にするためにnullチェックは省略します）。
public class Contact implements Comparable<Contact> {
private String name;
private String phone;
private Address address;
public int compareTo(Contact other) {
return name.compareTo(other.name);
}
// Add/generate getters/setters and other boilerplate.
}
あなたができるように
List<Contact> contacts = new ArrayList<Contact>();
// Fill it.
Collections.sort(contacts);
外部の制御可能な順序付け（自然な順序付けをオーバーライドする）を定義する場合は、次のように作成する必要がありますComparator。
List<Contact> contacts = new ArrayList<Contact>();
// Fill it.
// Now sort by address instead of name (default).
Collections.sort(contacts, new Comparator<Contact>() {
public int compare(Contact one, Contact other) {
return one.getAddress().compareTo(other.getAddress());
}
});
Comparators Contact自体を定義して、毎回再作成する代わりに再利用できるようにすることもできます。
public class Contact {
private String name;
private String phone;
private Address address;
// ...
public static Comparator<Contact> COMPARE_BY_PHONE = new Comparator<Contact>() {
public int compare(Contact one, Contact other) {
return one.phone.compareTo(other.phone);
}
};
public static Comparator<Contact> COMPARE_BY_ADDRESS = new Comparator<Contact>() {
public int compare(Contact one, Contact other) {
return one.address.compareTo(other.address);
}
};
}
これは次のように使用できます。
List<Contact> contacts = new ArrayList<Contact>();
// Fill it.
// Sort by address.
Collections.sort(contacts, Contact.COMPARE_BY_ADDRESS);
// Sort later by phone.
Collections.sort(contacts, Contact.COMPARE_BY_PHONE);
そして、トップを締めくくるには、一般的なjavabeanコンパレータの使用を検討することができます。
public class BeanComparator implements Comparator<Object> {
private String getter;
public BeanComparator(String field) {
this.getter = "get" + field.substring(0, 1).toUpperCase() + field.substring(1);
}
public int compare(Object o1, Object o2) {
try {
if (o1 != null && o2 != null) {
o1 = o1.getClass().getMethod(getter, new Class[0]).invoke(o1, new Object[0]);
o2 = o2.getClass().getMethod(getter, new Class[0]).invoke(o2, new Object[0]);
}
} catch (Exception e) {
// If this exception occurs, then it is usually a fault of the developer.
throw new RuntimeException("Cannot compare " + o1 + " with " + o2 + " on " + getter, e);
}
return (o1 == null) ? -1 : ((o2 == null) ? 1 : ((Comparable<Object>) o1).compareTo(o2));
}
}
次のように使用できます。
// Sort on "phone" field of the Contact bean.
Collections.sort(contacts, new BeanComparator("phone"));
（コードを見るとわかるように、並べ替え中のNPEを回避するために、nullのフィールドがすでにカバーされています）
String.CASE_INSENSITIVE_ORDER。友人や友人からもらったのですが、気に入っています。結果のコードを読みやすくします。
staticし、多分final...あまりにも...またはそのような何か
(o1 == null && o2 == null) ? 0 :、その戻り行の先頭にaが必要ですか？）
すでに投稿されているものに加えて、Java 8以降、コードを短くして次のように記述できることを知っておく必要があります。
Collection.sort(yourList, Comparator.comparing(YourClass::getFieldToSortOn));またはリストがsortメソッドを持っているので
yourList.sort(Comparator.comparing(YourClass::getFieldToSortOn));Java 8以降、機能インターフェース（抽象メソッドが1つしかないインターフェース-デフォルトまたは静的メソッドを追加できるインターフェース）は、以下を使用して簡単に実装できます。
Comparator<T>抽象メソッドが1つしかないので、int compare(T o1, T o2)これは機能的なインターフェイスです。
Collections.sort(contacts, new Comparator<Contact>() {
public int compare(Contact one, Contact other) {
return one.getAddress().compareTo(other.getAddress());
}
});
このコードを次のように削減できます。
Collections.sort(contacts, (Contact one, Contact other) -> {
return one.getAddress().compareTo(other.getAddress());
});この（または任意の）ラムダをスキップして簡略化できます
{return...}だから代わりに
(Contact one, Contact other) -> {
return one.getAddress().compareTo(other.getAddress();
}我々は書ける
(one, other) -> one.getAddress().compareTo(other.getAddress())また、今Comparatorのような静的なメソッドを持っているcomparing(FunctionToComparableValue)か、comparing(FunctionToValue, ValueComparator)我々は簡単にオブジェクトからいくつかの特定の値を比較すべきであるコンパレータを作成するために使用することができました。
つまり、上記のコードを次のように書き換えることができます。
Collections.sort(contacts, Comparator.comparing(Contact::getAddress));
//assuming that Address implements Comparable (provides default order).このページでは、ArrayListなど、コレクションの並べ替えについて知っておく必要があるすべてのことを説明しています。
基本的にあなたはする必要があります
ContactクラスにComparableインターフェースを
実装させるpublic int compareTo(Contact anotherContact)ます。Collections.sort(myContactList);。
myContactListでArrayList<Contact>（または任意の他のコレクションContact）。Comparatorクラスの作成を含む別の方法もあり、リンクされたページからもそれについて読むことができます。
例：
public class Contact implements Comparable<Contact> {
....
//return -1 for less than, 0 for equals, and 1 for more than
public compareTo(Contact anotherContact) {
int result = 0;
result = getName().compareTo(anotherContact.getName());
if (result != 0)
{
return result;
}
result = getNunmber().compareTo(anotherContact.getNumber());
if (result != 0)
{
return result;
}
...
}
}BalusCとbguizは、Javaの組み込みコンパレータを使用する方法について非常に完全な回答をすでに提供しています。
google-collectionsに、標準のコンパレータよりも「強力」なOrderingクラスがあることを追加したいだけです。チェックアウトする価値があるかもしれません。オブジェクトの関数の結果に応じて、順序付けの複合化、逆転、順序付けなどのクールなことを行うことができます...
これは、その利点のいくつかについて言及しているブログ投稿です。
ContactクラスにComparableを実装してから、compareTo(Contact)メソッドを実装する必要があります。そうすることで、Collections.sortがそれらをソートできるようになります。リンク先のページごとに、compareToは、このオブジェクトが指定されたオブジェクトより小さい、等しい、または大きいため、負の整数、ゼロ、または正の整数を返します。
たとえば、名前（AからZ）で並べ替える場合、クラスは次のようになります。
public class Contact implements Comparable<Contact> {
private String name;
// all the other attributes and methods
public compareTo(Contact other) {
return this.name.compareTo(other.name);
}
}Collections.sortは良いソート実装です。Contactに対応するCompareを実装していない場合は、Comparatorの実装を渡す必要があります。
注意：
ソートアルゴリズムは変更されたマージソートです（下位サブリストの最高の要素が上位サブリストの最低の要素よりも小さい場合、マージは省略されます）。このアルゴリズムは、n log（n）のパフォーマンスを保証します。指定されたリストは変更可能でなければなりませんが、サイズ変更可能である必要はありません。この実装は、指定されたリストを配列にダンプし、配列をソートし、リストを反復処理して、配列内の対応する位置から各要素をリセットします。これにより、リンクされたリストを所定の位置にソートしようとすることから生じるn2 log（n）パフォーマンスが回避されます。
マージソートは、おそらく、実行できるほとんどの検索アルゴリズムよりも優れています。
以下の方法で行いました。番号と名前は2つのarraylistです。名前を並べ替える必要があります。arralistの名前を変更すると、arraylistの番号も変更されます。
public void sortval(){
String tempname="",tempnum="";
if (name.size()>1) // check if the number of orders is larger than 1
{
for (int x=0; x<name.size(); x++) // bubble sort outer loop
{
for (int i=0; i < name.size()-x-1; i++) {
if (name.get(i).compareTo(name.get(i+1)) > 0)
{
tempname = name.get(i);
tempnum=number.get(i);
name.set(i,name.get(i+1) );
name.set(i+1, tempname);
number.set(i,number.get(i+1) );
number.set(i+1, tempnum);
}
}
}
}
}この方法を使用します。
private ArrayList<myClass> sortList(ArrayList<myClass> list) {
if (list != null && list.size() > 1) {
Collections.sort(list, new Comparator<myClass>() {
public int compare(myClass o1, myClass o2) {
if (o1.getsortnumber() == o2.getsortnumber()) return 0;
return o1.getsortnumber() < o2.getsortnumber() ? 1 : -1;
}
});
}
return list;
}`
使用：mySortedlist = sortList(myList);
クラスにコンパレータを実装する必要はありません。あなたは逆の順序スワップをしたい場合1や-1
わかりました、これはかなり前に回答されたと思います...しかし、ここにいくつかの新しい情報があります：
問題のContactクラスに、Comparableの実装による定義済みの自然な順序がすでにあるが、その名前を名前でオーバーライドしたいとします。これを行う最新の方法は次のとおりです。
List<Contact> contacts = ...;
contacts.sort(Comparator.comparing(Contact::getName).reversed().thenComparing(Comparator.naturalOrder());この方法では、最初に名前で（逆の順序で）ソートされ、次に名前の衝突の場合、Contactクラス自体によって実装された「自然な」順序にフォールバックします。
Arrays.sort関数を使用する必要があります。包含クラスはComparableを実装する必要があります。