1239

我阅读了有关使用 Comparator 对 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);
    ...
}
4

29 回答 29

1669

由于Dateimplements Comparable，它有一个compareTo方法，就像Stringdoes 一样。

因此，您的自定义Comparator可能如下所示：

public class CustomComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
}

该compare()方法必须返回 a ，因此无论如何您都不能像您计划的那样int直接返回 a 。boolean

你的排序代码就像你写的一样：

Collections.sort(Database.arrayList, new CustomComparator());

如果您不需要重用比较器，那么编写所有这些的稍微短一点的方法是将其编写为内联匿名类：

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

由于

您现在可以使用lambda 表达式以更短的形式编写最后一个示例Comparator：

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

并且List有一个sort(Comparator)方法，所以你可以进一步缩短它：

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

这是一个常见的习惯用法，有一个内置方法Comparator可以为具有键的类生成一个Comparable：

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

所有这些都是等价的形式。

于 2010-05-06T21:18:23.063 回答
198

具有自然排序顺序的类（例如 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) {
        ...
    }
});
于 2010-05-06T21:45:27.547 回答
162

对于排序，ArrayList您可以使用以下代码片段：

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});
于 2012-05-06T13:50:54.777 回答
46

JAVA 8 lambda 表达式

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)
于 2014-09-05T13:10:20.577 回答
44

是的你可以。比较项目有两个选项，Comparable接口和Comparator接口。

这两个接口都允许不同的行为。Comparable 允许您使对象的行为就像您刚刚描述的字符串一样（实际上，String 实现了 Comparable）。第二个，比较器，允许你做你要求做的事情。你会这样做：

Collections.sort(myArrayList, new MyComparator());

这将导致 Collections.sort 方法将比较器用于其排序机制。如果 ArrayList 中的对象实现了可比较，您可以改为执行以下操作：

Collections.sort(myArrayList);

Collections类包含许多有用的常用工具。

于 2010-05-06T21:17:40.397 回答
38

使用 Java 8，您可以为比较器使用方法引用：

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));
于 2014-03-13T15:19:27.413 回答
14

由于技术每天都在出现，答案会随着时间而改变。我看了一下 LambdaJ，看起来很有趣。

您可以尝试使用LambdaJ解决这些任务。你可以在这里找到它：http ://code.google.com/p/lambdaj/

这里有一个例子：

排序迭代

List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
        public int compare(Person p1, Person p2) {
           return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
        }
});

使用 lambda 排序

List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge());

当然，这种美感对性能有影响（平均为 2 倍），但你能找到更可读的代码吗？

于 2014-03-12T17:49:34.420 回答
13 
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());
    }

}

}
于 2012-04-03T15:32:34.090 回答
9

功能和方法参考

该Collections.sort方法可以List使用Comparator您传递的 a 对 a 进行排序。这Comparator可以使用可以根据需要传递方法引用的方法Comparator.comparing来实现Function。幸运的是，实际代码比这个描述更简单、更短。

对于 Java 8：

Collections.sort(list, comparing(ClassName::getName));

或者

Collections.sort(list, comparing(ClassName::getName).reversed());

另一种方法是

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));
于 2015-12-15T00:37:50.700 回答
9

JAVA 8 最简单的方法是英文字母排序

类实现

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

种类

  Collections.sort(Your List);

如果要对包含非英文字符的字母进行排序，可以使用 Locale... 下面的代码使用土耳其字符排序...

类实现

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());
于 2016-05-28T12:11:40.810 回答
7

您可以使用 java 8 进行排序

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));
于 2016-09-06T04:26:37.420 回答
6

Java 8 Lambda 缩短了排序。

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));
于 2015-09-09T14:18:12.750 回答
6

从那时Java 8起，我们不必Collections.sort()直接使用。List接口有一个默认sort()方法：

List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> { 
return u1.getFirstName.compareTo(u2.getFirstName());});

请参阅http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html。

于 2016-01-03T06:58:59.183 回答
5

您可以使用Bean Comparator对自定义类中的任何属性进行排序。

于 2010-05-06T21:29:16.000 回答
5

是的，这是可能的，例如在这个答案v中我按类的属性排序IndexValue 

    // 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）并将其直接传递给sort该类的方法Arrays

您的对象也可以实现Comparable（这就是 String 和 Java 中的大多数核心库所做的），但这将定义它自身的类的“自然排序顺序”，并且不允许您插入新的类。

于 2010-05-06T21:29:28.823 回答
5

我发现大多数（如果不是全部）这些答案都依赖于底层类（对象）来实现可比较或具有辅助可比较接口。

不是我的解决方案！以下代码可让您通过了解对象的字符串名称来比较对象的字段。您可以轻松地修改它以不使用该名称，但随后您需要公开它或构造您想要比较的对象之一。

Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));

public class ReflectiveComparator {
    public class FieldComparator implements Comparator<Object> {
        private String fieldName;

        public FieldComparator(String fieldName){
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);

                Comparable object1FieldValue = (Comparable) field.get(object1);
                Comparable object2FieldValue = (Comparable) field.get(object2);

                return object1FieldValue.compareTo(object2FieldValue);
            }catch (Exception e){}

            return 0;
        }
    }

    public class ListComparator implements Comparator<Object> {
        private String fieldName;

        public ListComparator(String fieldName) {
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);
                Comparable o1FieldValue = (Comparable) field.get(object1);
                Comparable o2FieldValue = (Comparable) field.get(object2);

                if (o1FieldValue == null){ return -1;}
                if (o2FieldValue == null){ return 1;}
                return o1FieldValue.compareTo(o2FieldValue);
            } catch (NoSuchFieldException e) {
                throw new IllegalStateException("Field doesn't exist", e);
            } catch (IllegalAccessException e) {
                throw new IllegalStateException("Field inaccessible", e);
            }
        }
    }
}
于 2012-04-25T19:28:41.087 回答
5

您可以尝试番石榴订购：

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);
于 2013-03-16T23:06:15.253 回答
3

您的 customComparator 类必须实现 java.util.Comparator 才能使用。它还必须覆盖 compare() AND equals()

compare() 必须回答这个问题：对象 1 是否小于、等于或大于对象 2？

完整文档：http: //java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

于 2010-05-06T21:20:17.160 回答
3

此代码片段可能很有用。如果您想对我的对象进行排序，我想按 VolumeName 进行排序：

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

这行得通。我在我的jsp中使用它。

于 2013-02-04T11:29:42.150 回答
3

使用此处的此库，您可以对多列上的自定义对象列表进行排序。该库使用 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);
于 2015-09-26T16:37:25.377 回答
3

您可以查看2016 年在德国斯图加特举行的 Java 论坛上的此演示文稿。

只有少数幻灯片使用德语，99% 的内容是“基于英语的”Java 源代码；像

someCollection.sort(
  OurCustomComparator
    .comparing(Person::getName)
    .thenComparing(Person::getId)
);

在哪里OurCustomComparator使用默认方法（和其他有趣的想法）。如图所示，导致代码非常简洁，可以选择一些 getter 方法进行排序；和排序标准的超级简单链接（或反转）。

如果您对 java8 感兴趣，您会发现那里有很多材料可以帮助您入门。

于 2016-12-20T12:49:37.100 回答
3

自 1.8 以来的新功能是 List.sort() 方法，而不是使用 Collection.sort()，因此您可以直接调用 mylistcontainer.sort()

这是一个演示 List.sort() 功能的代码片段：

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
于 2017-05-31T14:26:25.803 回答
3

好吧，如果您使用 Java 8 或更早版本，这是最好的解决方案。

Collections.sort(studentList, Comparator.comparing(Student::getCgpa).reversed().thenComparing(Student:: getFname).thenComparing(Student::getId));

在这种情况下，它将首先使用“getCgpa”进行排序，第二部分将使用 getFname 和 getId 进行排序。这是 pojo 类的领域。

于 2020-07-17T01:01:15.317 回答
1

我更喜欢这个过程：

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

如果您的对象列表有一个名为 的属性startDate，则您会一遍又一遍地调用 use this。你甚至可以把它们串起来startDate.time。

这要求您的对象是Comparable，这意味着您需要一个compareTo、equals和hashCode实现。

是的，它可能会更快......但是现在您不必为每种类型的排序创建一个新的比较器。如果您可以节省开发时间并放弃运行时，您可能会选择这个。

于 2010-05-06T23:43:30.063 回答
1

使用 java-8 流 api，您可以ArrayList按以下方式排序：

 Comparator<Person> birthdayComparator = Comparator.comparing(Person::getBirthday);
 List<Person> sortedList = list.stream().sorted(birthdayComparator).collect(toList());
于 2020-04-09T20:33:29.350 回答
0

使用 Java 8 使用可以Comparator在一行中定义使用Comparator.comparing()

使用以下任一方式：

选项1：

listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));

选项 2：

Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));
于 2018-03-21T09:36:10.970 回答
0

您的自定义类可以实现“Comparable”接口，这需要实现 CompareTo 方法。在 CompareTo 方法中，您可以定义一个对象小于或大于另一个对象的含义。所以在你的例子中，它看起来像这样：

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

负数表示它小于被比较的对象。正数表示这大于比较对象，零表示对象相等。

然后，您可以使用 collections.sort(myList) 对列表进行排序，而无需输入比较器。如果您使用已排序的集合数据结构（如 TreeSet 或 TreeMap），此方法还具有自动排序的优点。

如果您想了解更多关于 Comparable 接口的信息，可以查看这篇文章（披露：我是作者；）） https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

于 2018-12-28T20:17:03.213 回答
0

如果您只有要排序的（嵌套）属性的 String 属性路径，也可以使用 Springs PropertyComparator ：

List<SomeObject> list = ...;
PropertyComparator<HitWithInfo> propertyComparator = new PropertyComparator<>(
    "property.nested.myProperty", false, true);
list.sort(propertyComparator);

缺点是，此比较器会默默地忽略不存在或不可访问的属性，并将其作为空值处理以进行比较。这意味着，您应该仔细测试这样的比较器或以某种方式验证属性路径的存在。

于 2020-01-30T13:36:10.567 回答
-1

我在互联网上尝试了很多不同的解决方案，但对我有用的解决方案可以在下面的链接中找到。

https://www.java67.com/2017/07/how-to-sort-arraylist-of-objects-using.html

于 2020-04-21T03:12:18.967 回答