我读过关于使用比较器排序数组列表的内容，但在所有的例子中，人们都使用了compareTo，根据一些研究，它是字符串的一种方法。
我想根据自定义对象的一个属性(Date对象)对其数组列表进行排序 (getStartDay())。通常我通过item1.getStartDate().before(item2.getStartDate())比较它们，所以我想知道我是否可以写一些像这样的东西:
public class CustomComparator {
public boolean compare(Object object1, Object object2) {
return object1.getStartDate().before(object2.getStartDate());
}
}
public class RandomName {
...
Collections.sort(Database.arrayList, new CustomComparator);
...
}
当前回答
对于数组列表的排序，你可以使用下面的代码片段:
Collections.sort(studList, new Comparator<Student>(){
public int compare(Student s1, Student s2) {
return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
}
});
其他回答
是的，你可以。比较项有两个选项，Comparable接口和Comparator接口。
这两个接口都允许不同的行为。Comparable允许您使对象的行为与您刚刚描述的String类似(实际上，String实现了Comparable)。第二个，Comparator，允许你做你要求做的事情。你会这样做:
Collections.sort(myArrayList, new MyComparator());
这将导致收集。方法来使用比较器的排序机制。如果数组列表中的对象实现了可比性，你可以这样做:
Collections.sort(myArrayList);
Collections类包含许多这些有用的常用工具。
使用这个库，您可以对自定义对象列表进行多列排序。该库使用8.0版本的特性。样品也可在那里。这里有一个要做的示例
SortKeys sortKeys = new SortKeys();
sortKeys.addField("firstName")
.addField("age", true); // This (true) will sort the age descending
// Other ways to specify a property to the sorter are
// .addField("lastName", String.class);
// .addField("dob", Date.class, true);
// Instantiate a ListSorter
ListSorter listSorter = new ListSorter();
// Pass the data to sort (listToSort) and the "by keys" to sort (sortKeys)
List sortedList = (List<Person>) listSorter.sortList(listToSort, sortKeys);
具有自然排序顺序的类(例如类Number)应该实现Comparable接口，而没有自然排序顺序的类(例如类Chair)应该提供Comparator(或匿名Comparator类)。
两个例子:
public class Number implements Comparable<Number> {
private int value;
public Number(int value) { this.value = value; }
public int compareTo(Number anotherInstance) {
return this.value - anotherInstance.value;
}
}
public class Chair {
private int weight;
private int height;
public Chair(int weight, int height) {
this.weight = weight;
this.height = height;
}
/* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
public int compare(Chair chair1, Chair chair2) {
return chair1.getWeight() - chair2.getWeight();
}
}
class ChairHeightComparator implements Comparator<Chair> {
public int compare(Chair chair1, Chair chair2) {
return chair1.getHeight() - chair2.getHeight();
}
}
用法:
List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);
List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());
// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
public int compare(Chair chair1, Chair chair2) {
...
}
});
是的，这是可能的，例如在这个答案中，我根据类IndexValue的属性v进行排序
// Sorting by property v using a custom comparator.
Arrays.sort( array, new Comparator<IndexValue>(){
public int compare( IndexValue a, IndexValue b ){
return a.v - b.v;
}
});
如果您注意到这里，我正在创建一个匿名的内部类(这是用于闭包的Java)，并将其直接传递给类Arrays的排序方法
您的对象也可以实现Comparable(这是String和Java中的大多数核心库所做的)，但这将定义类本身的“自然排序顺序”，并且不允许您插入新的类。
如果你想要排序的(嵌套的)属性只有String属性路径，你也可以使用Springs PropertyComparator:
List<SomeObject> list = ...;
PropertyComparator<HitWithInfo> propertyComparator = new PropertyComparator<>(
"property.nested.myProperty", false, true);
list.sort(propertyComparator);
缺点是，这个比较器会默默地忽略不存在或不可访问的属性，并将其作为空值进行比较。这意味着，您应该仔细测试这样的比较器，或者以某种方式验证属性路径的存在。
