Answers:
这是有关订购对象的教程：
尽管我会举一些例子，但我还是建议您阅读它。
有多种方法可以排序ArrayList。如果要定义自然的（默认）排序，则需要让ContactImplement实现Comparable。假设您想在上默认进行排序name，然后执行（为简单起见，省略了nullchecks）：
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());
}
}); 您甚至可以Comparator在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）
String.CASE_INSENSITIVE_ORDER朋友那里得到的，但是我喜欢。使结果代码更易于阅读。
static，也许final太...或者类似的东西..
(o1 == null && o2 == null) ? 0 :在该返回行的开头？）
除了已经发布的内容之外，您还应该知道，自Java 8以来，我们可以缩短代码并将其编写为：
Collection.sort(yourList, Comparator.comparing(YourClass::getFieldToSortOn));或因为列表现在有sort方法
yourList.sort(Comparator.comparing(YourClass::getFieldToSortOn));从Java 8开始，可以使用以下方法轻松实现功能接口（只有一种抽象方法的接口-它们可以具有更多的默认或静态方法）。
由于Comparator<T>只有一种抽象方法，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());
});我们可以通过跳过来简化此（或任何）lambda
{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的内置比较器给出了非常完整的答案。
我只想补充一下，谷歌收藏有一个Ordering类，它比标准Comparators更加“强大”。可能值得一试。您可以做一些很酷的事情，例如复合排序，反转它们，根据对象的函数结果排序...
这是一篇博客文章，其中提到了一些好处。
您需要使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);
}
}我是通过以下方式做到的。数字和名称是两个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。