如何按某些属性对对象列表进行排序

Question

我有简单的类

public class ActiveAlarm {
    public long timeStarted;
    public long timeEnded;
    private String name = "";
    private String description = "";
    private String event;
    private boolean live = false;
}

和 List con。如何按 timeStarted 升序排序，然后按 timeEnded 升序排序？有人可以帮忙吗？我知道 C++ 中有通用算法和重载运算符 <，但我对 Java 很陌生。

Answer 1

使用 比较器

例如：

class Score {

    private String name;
    private List<Integer> scores;
    // +accessor methods
}

---

    Collections.sort(scores, new Comparator<Score>() {

        public int compare(Score o1, Score o2) {
            // compare two instance of `Score` and return `int` as result.
            return o2.getScores().get(0).compareTo(o1.getScores().get(0));
        }
    });

从 Java 8 开始，您可以简单地使用 lambda 表达式来表示 Comparator 实例。

Collections.sort(scores, (s1, s2) -> { /* compute and return int */ });

Answer 2

使 ActiveAlarm 实现 Comparable 或在单独的类中实现 Comparator。然后调用：

Collections.sort(list);

或者

Collections.sort(list, comparator);

一般来说，实现 是个好主意Comparable如果有一个“自然”排序顺序...否则（如果您碰巧想要按特定顺序排序，但可能同样容易想要一个不同的）最好实现 Comparator。老实说，这种特殊情况可能会发生任何一种情况......但我可能坚持使用更灵活的Comparator选项。

编辑：示例实现：

public class AlarmByTimesComparer implements Comparator<ActiveAlarm> {
  @Override
  public int compare(ActiveAlarm x, ActiveAlarm y) {
    // TODO: Handle null x or y values
    int startComparison = compare(x.timeStarted, y.timeStarted);
    return startComparison != 0 ? startComparison
                                : compare(x.timeEnded, y.timeEnded);
  }

  // I don't know why this isn't in Long...
  private static int compare(long a, long b) {
    return a < b ? -1
         : a > b ? 1
         : 0;
  }
}

Answer 3

JAVA 8 及以上答案（使用 Lambda 表达式）

在 Java 8 中，引入了 Lambda 表达式，使这变得更加容易！您可以将其简化如下：（使用您的对象作为示例）

Collections.sort(list, (ActiveAlarm a1, ActiveAlarm a2) -> a1.timeStarted-a2.timeStarted);

甚至更短：

Collections.sort(list, Comparator.comparingInt(ActiveAlarm ::getterMethod));

该语句相当于以下内容：

Collections.sort(list, new Comparator<ActiveAlarm>() {
    @Override
    public int compare(ActiveAlarm a1, ActiveAlarm a2) {
        return a1.timeStarted - a2.timeStarted;
    }
});

将 Lambda 表达式视为仅需要您放入代码的相关部分：方法签名和返回的内容。

您问题的另一部分是如何与多个字段进行比较。要使用 Lambda 表达式执行此操作，您可以使用 .thenComparing() 函数有效地将两个比较合并为一个：

Collections.sort(list, (ActiveAlarm a1, ActiveAlarm a2) -> a1.timeStarted-a2.timeStarted             
       .thenComparing ((ActiveAlarm a1, ActiveAlarm a2) -> a1.timeEnded-a2.timeEnded)
);

上面的代码将首先按 timeStarted 对列表进行排序，然后然后按 timeEnded（对于那些具有相同 timeStarted 的记录）。

最后一点：比较“long”或“int”基元很容易，您只需将其中一个减去另一个即可。如果您正在比较对象（“Long”或“String”），我建议您使用它们的内置比较。示例：

Collections.sort(list, (ActiveAlarm a1, ActiveAlarm a2) -> a1.name.compareTo(a2.name) );

编辑：感谢 Lukas Eder 将我指向 .thenComparing() 函数。

Answer 4

我们可以通过以下两种方式之一对列表进行排序：

1.使用Comparator：当需要在多个地方使用排序逻辑时
如果您想在单个位置使用排序逻辑，那么您可以编写一个匿名内部类，如下所示，或者提取比较器并在多个位置使用它

  Collections.sort(arrayList, new Comparator<ActiveAlarm>() {
        public int compare(ActiveAlarm o1, ActiveAlarm o2) {
            //Sorts by 'TimeStarted' property
            return o1.getTimeStarted()<o2.getTimeStarted()?-1:o1.getTimeStarted()>o2.getTimeStarted()?1:doSecodaryOrderSort(o1,o2);
        }

        //If 'TimeStarted' property is equal sorts by 'TimeEnded' property
        public int doSecodaryOrderSort(ActiveAlarm o1,ActiveAlarm o2) {
            return o1.getTimeEnded()<o2.getTimeEnded()?-1:o1.getTimeEnded()>o2.getTimeEnded()?1:0;
        }
    });

如果我们可以使用 '长”而不是“长”。

2.使用 Comparable（自然排序）：如果排序算法始终坚持一个属性：
编写一个实现“Comparable”的类并重写“compareTo”方法，如下定义

class ActiveAlarm implements Comparable<ActiveAlarm>{

public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;

public ActiveAlarm(long timeStarted,long timeEnded) {
    this.timeStarted=timeStarted;
    this.timeEnded=timeEnded;
}

public long getTimeStarted() {
    return timeStarted;
}

public long getTimeEnded() {
    return timeEnded;
}

public int compareTo(ActiveAlarm o) {
    return timeStarted<o.getTimeStarted()?-1:timeStarted>o.getTimeStarted()?1:doSecodaryOrderSort(o);
}

public int doSecodaryOrderSort(ActiveAlarm o) {
    return timeEnded<o.getTimeEnded()?-1:timeEnded>o.getTimeEnded()?1:0;
}

}

调用排序方法根据自然顺序进行排序

Collections.sort(list);

Answer 5

在java8+中，这可以单行编写，如下所示：

collectionObjec.sort(comparator_lamda)或comparator.comparing(CollectionType::getterOfProperty)

代码：

ListOfActiveAlarmObj.sort((a,b->a.getTimeStarted().compareTo(b.getTimeStarted())))
 

或

ListOfActiveAlarmObj.sort(Comparator.comparing(ActiveAlarm::getTimeStarted))

Answer 6

public class ActiveAlarm implements Comparable<ActiveAlarm> {
    public long timeStarted;
    public long timeEnded;
    private String name = "";
    private String description = "";
    private String event;
    private boolean live = false;

    public int compareTo(ActiveAlarm a) {
        if ( this.timeStarted > a.timeStarted )
            return 1;
        else if ( this.timeStarted < a.timeStarted )
            return -1;
        else {
             if ( this.timeEnded > a.timeEnded )
                 return 1;
             else
                 return -1;
        }
 }

这应该会给你一个粗略的想法。完成后，您可以在列表上调用 Collections.sort()。

Answer 7

从 Java8 开始，使用 < 的组合可以更干净地完成此操作code>Comparator 和 Lambda 表达式

例如：

class Student{

    private String name;
    private List<Score> scores;

    // +accessor methods
}

class Score {

    private int grade;
    // +accessor methods
}

---

    Collections.sort(student.getScores(), Comparator.comparing(Score::getGrade);

Answer 8

使用 Stream API< 的 Java-8 解决方案/a>:

A. 当 timeStarted 和 timeEnded 为 public 时（如要求中所述），因此执行不（需要）有public getter 方法：

List<ActiveAlarm> sorted = 
    list.stream()
        .sorted(Comparator.comparingLong((ActiveAlarm alarm) -> alarm.timeStarted)
                        .thenComparingLong((ActiveAlarm alarm) -> alarm.timeEnded))
        .collect(Collectors.toList());

B. 当 timeStarted 和 timeEnded 有 public getter 方法时：

List<ActiveAlarm> sorted = 
    list.stream()
        .sorted(Comparator.comparingLong(ActiveAlarm::getTimeStarted)
                        .thenComparingLong(ActiveAlarm::getTimeEnded))
        .collect(Collectors.toList());

如果您想对原始列表本身进行排序：

A.当timeStarted和timeEnded是public< /code> （如要求中所述），因此不需要（需要）具有 public getter 方法：

list.sort(Comparator.comparingLong((ActiveAlarm alarm) -> alarm.timeStarted)
                    .thenComparingLong((ActiveAlarm alarm) -> alarm.timeEnded));

B. 当 timeStarted 和 timeEnded 具有 public 时获取方法：

list.sort(Comparator.comparingLong(ActiveAlarm::getTimeStarted)
                    .thenComparingLong(ActiveAlarm::getTimeEnded));

Answer 9

Guava 的比较链：

Collections.sort(list, new Comparator<ActiveAlarm>(){
            @Override
            public int compare(ActiveAlarm a1, ActiveAlarm a2) {
                 return ComparisonChain.start()
                       .compare(a1.timestarted, a2.timestarted)
                       //...
                       .compare(a1.timeEnded, a1.timeEnded).result();
            }});

Answer 10

这就是对我有用的东西。
比我发现的其他内容更短、更容易：

Collections.sort(listName, Comparator.comparing(Object::getProperty).reversed());

最后的“.reversed()”部分是我的特定项目的要求，但我也分享它，因为花了一段时间才找到它

Answer 11

我们可以使用 Comparator.comparing() 方法根据对象的属性对列表进行排序。

class SortTest{
    public static void main(String[] args) {
        ArrayList<ActiveAlarm> activeAlarms = new ArrayList<>(){{
            add(new ActiveAlarm("Alarm 1", 5, 10));
            add(new ActiveAlarm("Alarm 2", 2, 12));
            add(new ActiveAlarm("Alarm 3", 0, 8));
        }};

        /* I sort the arraylist here using the getter methods */
        activeAlarms.sort(Comparator.comparing(ActiveAlarm::getTimeStarted)
                .thenComparing(ActiveAlarm::getTimeEnded));

        System.out.println(activeAlarms);
    }
}

请注意，在执行此操作之前，您必须至少定义要作为排序基础的属性的 getter 方法。

public class ActiveAlarm {
    public long timeStarted;
    public long timeEnded;
    private String name = "";
    private String description = "";
    private String event;
    private boolean live = false;

    public ActiveAlarm(String name, long timeStarted, long timeEnded) {
        this.name = name;
        this.timeStarted = timeStarted;
        this.timeEnded = timeEnded;
    }

    public long getTimeStarted() {
        return timeStarted;
    }

    public long getTimeEnded() {
        return timeEnded;
    }

    @Override
    public String toString() {
        return name;
    }
}

输出：

[Alarm 3, Alarm 2, Alarm 1]

Answer 12

员工PO​​JO类

package in.ac.adit.oop.sort;

public class Employee {
    private int id;
    private String name;
    private String department;

    public int getId() {
        return id;
    }

    public Employee() {
        super();
    }

    public Employee(int id, String name, String department) {
        super();
        this.id = id;
        this.name = name;
        this.department = department;
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", department=" + department + "]";
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }
}

员工类来管理员工

package in.ac.adit.oop.sort;

import java.util.ArrayList;
import java.util.List;

    public class Example {
        public static void main(String[] args) {
    
            /*
             * Create 10 Employee Object
             */
            Employee emp1 = new Employee(1, "Nayan", "IT");
            Employee emp2 = new Employee(2, "Siddarth", "CP");
            Employee emp3 = new Employee(3, "Samarth", "AE");
            Employee emp4 = new Employee(4, "Bhavesh", "CV");
            Employee emp5 = new Employee(5, "Sam", "FT");
            Employee emp6 = new Employee(6, "Keyur", "IT");
            Employee emp7 = new Employee(7, "Bala", "ME");
            Employee emp8 = new Employee(8, "Mitul", "ME");
            Employee emp9 = new Employee(9, "Kamlesh", "EE");
            Employee emp10 = new Employee(10, "Piyush", "EE");
    
            /*
             * List of Employee Object
             */
            List<Employee> employeeList = new ArrayList<Employee>();
            employeeList.add(emp1);
            employeeList.add(emp2);
            employeeList.add(emp3);
            employeeList.add(emp4);
            employeeList.add(emp5);
            employeeList.add(emp6);
            employeeList.add(emp7);
            employeeList.add(emp8);
            employeeList.add(emp9);
            employeeList.add(emp10);
    
            CustomObjectSort customObjectSort = new CustomObjectSort();
            List<Employee> sortByDepartment = customObjectSort.sortByDepartment(employeeList);
    
            /*
             * Sorted By Department
             */
            for (Employee employee : sortByDepartment) {
                System.out.println(employee);
            }
    
            /*
             * Sorted By Name
             */
            List<Employee> sortByName = customObjectSort.sortByName(employeeList);
    
            for (Employee employee : sortByName) {
                System.out.println(employee);
            }
    
            /*
             * Sorted By Id
             */
            List<Employee> sortById = customObjectSort.sortById(employeeList);
    
            for (Employee employee : sortById) {
                System.out.println(employee);
            }
    
        }
    }

自定义排序

package in.ac.adit.oop.sort;


import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CustomObjectSort {

    public List<Employee> sortByName(List<Employee> employeeList) {

        Collections.sort(employeeList, new Comparator<Employee>() {

            @Override
            public int compare(Employee employee1, Employee employee2) {
                return employee1.getName().compareTo(employee2.getName());
            }

        });
        return employeeList;
    }

    public List<Employee> sortByDepartment(List<Employee> employeeList) {

        Collections.sort(employeeList, new Comparator<Employee>() {

            @Override
            public int compare(Employee employee1, Employee employee2) {
                return employee1.getDepartment().compareTo(employee2.getDepartment());
            }

        });
        return employeeList;
    }

    public List<Employee> sortById(List<Employee> employeeList) {

        Collections.sort(employeeList, new Comparator<Employee>() {

            @Override
            public int compare(Employee employee1, Employee employee2) {
                return employee1.getId() - employee2.getId();
            }

        });
        return employeeList;
    }

}

Answer 13

您可以使用 Collections.sort 并传递您自己的 Comparator

Answer 14

在java中，您需要使用静态Collections.sort方法。下面是 CompanyRole 对象列表的示例，首先按开始排序，然后按结束排序。您可以轻松适应自己的对象。

private static void order(List<TextComponent> roles) {

    Collections.sort(roles, new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            int x1 = ((CompanyRole) o1).getBegin();
            int x2 = ((CompanyRole) o2).getBegin();

            if (x1 != x2) {
                return x1 - x2;
            } else {
                int y1 = ((CompanyRole) o1).getEnd();
                int y2 = ((CompanyRole) o2).getEnd();
                return y2 - y1;
            }
        }
    });
}

Answer 15

您可以调用 Collections.sort() 并传入一个比较器，您需要编写该比较器来比较对象的不同属性。

Answer 16

如前所述，您可以通过以下方式进行排序：

• 让您的对象实现 Comparable
• 或将 Comparator 传递给 Collections.sort

如果您同时执行这两个操作，则 Comparable 将被忽略，而 Comparator 将被使用。这有助于值对象拥有自己的逻辑Comparable，这对于您的值对象来说是最合理的排序，而每个单独的用例都有自己的实现。

Answer 17

public class ActiveAlarm {
    public long timeStarted;
    public long timeEnded;
    private String name = "";
    private String description = "";
    private String event;
    private boolean live = false;
}

List<ActiveAlarm> con = new ArrayList<ActiveAlarm>();

Collections.sort(con , (a1, a2) -> a1.timeStarted.compareTo(a2.timeStarted));
Collections.sort(con , (a1, a2) -> a1.timeEnded.compareTo(a2.timeEnded));

Answer 18

在 Java（Java 8 及更高版本）中对任何对象列表进行排序的最佳且最简单的方法。
让我们根据属性“fruitName”对一篮子水果进行排序

Fruit POJO：

class Fruit
{
    int price;
    String fruitName;
    
    
    public Fruit(int price, String fruitName) {
        super();
        this.price = price;
        this.fruitName = fruitName;
    }


    public int getPrice() {
        return price;
    }


    public void setPrice(int price) {
        this.price = price;
    }


    public String getFruitName() {
        return fruitName;
    }


    public void setFruitName(String fruitName) {
        this.fruitName = fruitName;
    }


    @Override
    public String toString() {
        return "Fruits [price=" + price + ", fruitName=" + fruitName + "]";
    }
    
}

现在让我们将水果添加到列表中，然后对其进行排序

List<Fruit> basketOfFruits = new ArrayList<>();
        basketOfFruits.add(new Fruit(123, "oranges"));
        basketOfFruits.add(new Fruit(45, "nectarine"));
        basketOfFruits.add(new Fruit(369, "blueberries"));
        basketOfFruits.add(new Fruit(248, "apple"));
        basketOfFruits.add(new Fruit(968, "peaches"));
        basketOfFruits.add(new Fruit(436, "grapes"));
        basketOfFruits.add(new Fruit(596, "figs"));
        
       //sorting by the property fruitName
        Collections.sort(basketOfFruits, (f1, f2)->{return f1.getFruitName().compareTo(f2.getFruitName());}); 

您现在可以打印列表（即basketOfFruits），并且列表中的水果将按升序排序（按字典顺序）。
输出如下所示：

[Fruits [price=248, fruitName=apple], Fruits [price=369, fruitName=blueberries], Fruits [price=596, fruitName=figs], Fruits [price=436, fruitName=grapes], Fruits [price=45, fruitName=nectarine], Fruits [price=123, fruitName=oranges], Fruits [price=968, fruitName=peaches]]

也可以使用 Java 流（Java 8 及更高版本）代替 Collections.sort()。以下是使用 Java 流的代码

List<Fruit> sortedFruits = basketOfFruits.stream().sorted( (f1, f2)->{return f1.getFruitName().compareTo(f2.getFruitName());}).collect(Collectors.toList());

，其中列表以与 Collections.sort() 相同的方式排序，但排序后的项目将存储/收集在另一个列表“sortedFruits”中。因此，如果我们想打印列表中已排序的项目，则在本例中需要打印“sortedFruits”而不是“basketOfFruits”