Java 按属性对自定义对象的ArrayList排序
我读过关于使用比较器对数组列表进行排序的文章,但在所有的例子中,人们都使用了Java 按属性对自定义对象的ArrayList排序,java,sorting,date,comparator,java-8,Java,Sorting,Date,Comparator,Java 8,我读过关于使用比较器对数组列表进行排序的文章,但在所有的例子中,人们都使用了compareTo,根据一些研究,这是一种字符串排序方法 我想按自定义对象的属性之一对其ArrayList进行排序:日期对象 (getStartDay())。通常我通过item1.getStartDate().before(item2.getStartDate())比较它们,所以我想知道是否可以编写如下内容: public class CustomComparator { public boolean compa
compareTo
,根据一些研究,这是一种字符串排序方法
我想按自定义对象的属性之一对其ArrayList进行排序:日期对象
(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);
...
}
是的,你可以。有两个用于比较项目的选项:接口和接口 这两个接口都允许不同的行为。Comparable允许您使对象的行为与刚才描述的字符串类似(实际上,字符串实现了Comparable)。第二个是Comparator,它允许你做你要求做的事情。你可以这样做:
Collections.sort(myArrayList, new MyComparator());
Collections.sort(myArrayList);
public class CustomComparator implements Comparator<MyObject> {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
}
public class MyCustomClass implements Comparable<MyCustomClass>{
这将导致Collections.sort方法使用comparator作为其排序机制。如果ArrayList中的对象实现了comparable,则可以执行以下操作:
Collections.sort(myArrayList, new MyComparator());
Collections.sort(myArrayList);
public class CustomComparator implements Comparator<MyObject> {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
}
public class MyCustomClass implements Comparable<MyCustomClass>{
该类包含许多有用的通用工具。自从实现以来,它与String
方法一样,有一个compareTo
方法
因此,您的自定义可以如下所示:
Collections.sort(myArrayList, new MyComparator());
Collections.sort(myArrayList);
public class CustomComparator implements Comparator<MyObject> {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
}
public class MyCustomClass implements Comparable<MyCustomClass>{
如果您不需要重用比较器,那么编写所有这些的一种略短的方法是将其作为内联匿名类编写:
Collections.sort(Database.arrayList, new Comparator<MyObject>() {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
});
而且List
有一个方法,因此您可以进一步缩短:
Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));
这是一种常见的习惯用法,需要为具有可比
键的类生成比较器
:
Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));
所有这些都是等效形式。您的customComparator类必须实现java.util.Comparator才能使用。 它还必须覆盖compare()和equals() compare()必须回答以下问题:对象1是否小于、等于或大于对象2
完整文档:您可以使用对自定义类中的任何属性进行排序。是的,例如在I排序中,可以根据类的属性
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;
}
});
//使用自定义比较器按属性v排序。
sort(数组,新的比较器(){
公共整数比较(索引值a、索引值b){
返回a.v-b.v;
}
});
如果您注意到这里,我正在创建一个匿名内部类(这是闭包的Java),并将其直接传递给类Arrays
的sort
方法
您的对象也可以实现
可比较的(这是String和Java中的大多数核心库所做的),但这将定义类本身的“自然排序顺序”,并且不允许您插入新的排序顺序。具有自然排序顺序(例如,类编号)的类应实现可比较接口,而没有自然排序顺序的类(例如,班主任)应该提供一个比较器(或匿名比较器类)
两个例子:
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();
}
}
公共类编号实现可比性{
私有int值;
公共编号(int值){this.value=value;}
公共int比较到(另一个实例的编号){
返回this.value-anotherInstance.value;
}
}
公共班主任{
私有整数权重;
私人内部高度;
公共座椅(内部重量、内部高度){
重量=重量;
高度=高度;
}
/*省略getter和setter*/
}
类Comparator实现Comparator{
公共int比较(主席1、主席2){
返回chair1.getWeight()-chair2.getWeight();
}
}
类ChairHeightComparator实现Comparator{
公共int比较(主席1、主席2){
返回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) {
...
}
});
List number=new ArrayList();
...
集合。排序(编号);
列表椅子=新的ArrayList();
//按重量排序:
Collections.sort(chairs,new ChairWeightComparator());
//按高度排序:
Collections.sort(椅子、新椅子高度比较器());
//您还可以创建匿名比较器;
//按颜色排序:
集合。排序(椅子、新比较器(){
公共int比较(主席1、主席2){
...
}
});
我更喜欢这个过程:
public class SortUtil
{
public static <T> List<T> sort(List<T> list, String sortByProperty)
{
Collections.sort(list, new BeanComparator(sortByProperty));
return list;
}
}
List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");
public-class-SortUtil
{
公共静态列表排序(列表列表、字符串sortByProperty)
{
排序(列表,新BeanComparator(sortByProperty));
退货清单;
}
}
List sortedList=SortUtil.sort(未排序列表,“开始日期”);
如果对象列表中有一个名为startDate
的属性,则可以反复调用该属性。你甚至可以链接它们startDate.time
这要求对象具有可比性,这意味着您需要一个比较器来实现
,等于
,以及哈希代码
实现
是的,它可以更快。。。但是现在您不必为每种类型的排序创建新的比较器。如果您可以节省开发时间,放弃运行时,那么您可以选择使用此选项。import java.text.ParseException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
public class test {
public static class Person {
public String name;
public int id;
public Date hireDate;
public Person(String iname, int iid, Date ihireDate) {
name = iname;
id = iid;
hireDate = ihireDate;
}
public String toString() {
return name + " " + id + " " + hireDate.toString();
}
// Comparator
public static class CompId implements Comparator<Person> {
@Override
public int compare(Person arg0, Person arg1) {
return arg0.id - arg1.id;
}
}
public static class CompDate implements Comparator<Person> {
private int mod = 1;
public CompDate(boolean desc) {
if (desc) mod =-1;
}
@Override
public int compare(Person arg0, Person arg1) {
return mod*arg0.hireDate.compareTo(arg1.hireDate);
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
ArrayList<Person> people;
people = new ArrayList<Person>();
try {
people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Collections.sort(people, new Person.CompId());
System.out.println("BY ID");
for (Person p : people) {
System.out.println(p.toString());
}
Collections.sort(people, new Person.CompDate(false));
System.out.println("BY Date asc");
for (Person p : people) {
System.out.println(p.toString());
}
Collections.sort(people, new Person.CompDate(true));
System.out.println("BY Date desc");
for (Person p : people) {
System.out.println(p.toString());
}
}
}
导入java.text.simpleDataFormat;
导入java.util.ArrayList;
导入java.util.Collections;
导入java.util.Comparator;
导入java.util.Date;
公开课考试{
公共静态类人员{
公共字符串名称;
公共int id;
公开日期租用;
公众人士(字符串iname、内部iid、日期ihireDate){
name=iname;
id=iid;
hireDate=ihireDate;
}
公共字符串toString(){
返回name+“”+id+“”+hireDate.toString();
}
//比较器
公共静态类CompId实现了Comparator{
@凌驾
公共整数比较(人员arg0、人员arg1){
返回arg0.id-arg1.id;
}
}
公共静态类CompDate实现了Comparator{
私有整数模=1;
公共CompDate(布尔描述){
Collections.sort(studList, (Student s1, Student s2) ->{
return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});
Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)
Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));
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);
Collections.sort(list, comparing(ClassName::getName));
Collections.sort(list, comparing(ClassName::getName).reversed());
Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));
List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> {
return u1.getFirstName.compareTo(u2.getFirstName());});
public class NewspaperClass implements Comparable<NewspaperClass>{
public String name;
@Override
public int compareTo(NewspaperClass another) {
return name.compareTo(another.name);
}
}
Collections.sort(Your List);
public class NewspaperClass implements Comparator<NewspaperClass> {
public String name;
public Boolean isUserNewspaper=false;
private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));
@Override
public int compare(NewspaperClass lhs, NewspaperClass rhs) {
trCollator.setStrength(Collator.PRIMARY);
return trCollator.compare(lhs.name,rhs.name);
}
}
Collections.sort(your array list,new NewspaperClass());
yourList.sort(Comparator.comparing(Classname::getName));
or
yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));
someCollection.sort(
OurCustomComparator
.comparing(Person::getName)
.thenComparing(Person::getId)
);
List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));
// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]
// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]
public class Fruit implements Comparable<Fruit>
{
private String name;
private String color;
private int quantity;
public Fruit(String name,String color,int quantity)
{ this.name = name; this.color = color; this.quantity = quantity; }
public String getFruitName() { return name; }
public String getColor() { return color; }
public int getQuantity() { return quantity; }
@Override public final int compareTo(Fruit f) // sorting the color
{
return this.color.compareTo(f.color);
}
@Override public String toString()
{
return (name + " is: " + color);
}
} // end of Fruit class
listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));
Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));
public class MyCustomClass implements Comparable<MyCustomClass>{
@Override
public int compareTo(MyCustomClass a) {
if(this.getStartDate().before(a.getStartDate())){
return -1;
}else if(a.getStartDate().before(this.getStartDate())){
return 1;
}else {
return 0;
}
}
List<SomeObject> list = ...;
PropertyComparator<HitWithInfo> propertyComparator = new PropertyComparator<>(
"property.nested.myProperty", false, true);
list.sort(propertyComparator);
Comparator<Person> birthdayComparator = Comparator.comparing(Person::getBirthday);
List<Person> sortedList = list.stream().sorted(birthdayComparator).collect(toList());
Collections.sort(studentList, Comparator.comparing(Student::getCgpa).reversed().thenComparing(Student:: getFname).thenComparing(Student::getId));