Java 按属性对自定义对象的ArrayList排序

我读过关于使用比较器对数组列表进行排序的文章，但在所有的例子中，人们都使用了

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));