Java Collections.sort（）比较器

我正在对自定义对象进行排序。自定义对象包含状态和时间戳。首先，我必须根据状态排序，然后是时间戳。具有以下值的状态

正在运行、等待、注册、完成和中止

所以，有值运行的状态应该排在前面，然后等待，等等

如果我必须按字母顺序排序，那么我可以通过

state1.compareTo(state2)

但是我可以用这个标准来排序吗。请帮我写这个逻辑

编辑

按照你们的建议，我选了Enum

private enum TournamentState {
    Running,
    Waiting,
    Registering,
    Completed,
    Aborted
}

并进行如下比较

int sort = EnumState.valueOf(status1).compareTo(EnumState.valueOf(status2));

if(sort != 0){
  return sort;
}else{
   return (int) (time1 - time2);
}

---

非常感谢您的支持。

您可以使用composition of comparator函数：

Comparator<MyClass> comparator = Comparator.comparing(MyClass::getState)
    .thenComparing(MyClass::getTimeStamp);

甚至

.thenComparing((ts1, ts2) -> {
    //custom comparison logic for time stamp values
    return result;
 });

Comparator。然后比较

与以下注释一起记录：

返回一个字典顺序比较器和另一个比较器。如果该比较器认为两个元素相等，即比较（a，b）==0，则使用另一个元素确定顺序

请注意，

MyClass.state

在这种情况下被假定为可比较的，例如作为一个枚举，它本质上是可比较的。如果是纯字符串，则可能也需要自定义逻辑，例如：

final String order = "Running, Waiting, Registering, Completed and Aborted";
Comparator<MyClass> comparator = 
  Comparator.comparingInt(e -> order.indexOf(e.getState()))
    .thenComparing(MyClass::getTimeStamp);

final String order=“正在运行、等待、注册、完成和中止”；
比较器比较器=
Comparator.comparingit（e->order.indexOf（e.getState（）））
.Then比较（MyClass:：getTimeStamp）；

您可以使用比较器函数的组合：

Comparator<MyClass> comparator = Comparator.comparing(MyClass::getState)
    .thenComparing(MyClass::getTimeStamp);

甚至

.thenComparing((ts1, ts2) -> {
    //custom comparison logic for time stamp values
    return result;
 });

Comparator。然后比较

与以下注释一起记录：

返回一个字典顺序比较器和另一个比较器。如果该比较器认为两个元素相等，即比较（a，b）==0，则使用另一个元素确定顺序

请注意，

MyClass.state

在这种情况下被假定为可比较的，例如作为一个枚举，它本质上是可比较的。如果是纯字符串，则可能也需要自定义逻辑，例如：

final String order = "Running, Waiting, Registering, Completed and Aborted";
Comparator<MyClass> comparator = 
  Comparator.comparingInt(e -> order.indexOf(e.getState()))
    .thenComparing(MyClass::getTimeStamp);

final String order=“正在运行、等待、注册、完成和中止”；
比较器比较器=
Comparator.comparingit（e->order.indexOf（e.getState（）））
.Then比较（MyClass:：getTimeStamp）；

您可以为

状态

类创建自定义比较器，如下所示：

public final class StateComparator implements Comparator<State>
{

    private int getRank(final State s)
    {
        if (s.getValue().equals("Running"))
        {
            return 1;
        } else if (s.getValue().equals("Waiting")) {
            return 2;
        } else if (s.getValue().equals("Registering")) {
            return 3;
        } else if (s.getValue().equals("Completed")) {
            return 4;
        } else if s.getValue().equals("Aborted") {
            return 5;
        } else {
            return Integer.MAX_VALUE;
        }

    }

    public int compare(final State s1, final State s3)
    {
        return getRank(s1) - getRank(S2);
    }

}

public final类stateparator实现Comparator
{
私有int getRank（最终状态s）
{
如果（s.getValue（）.equals（“Running”））
{
返回1；
}如果（s.getValue（）.equals（“Waiting”））{
返回2；
}如果（s.getValue（）.equals（“注册”））{
返回3；
}否则如果（s.getValue（）.equals（“已完成”））{
返回4；
}否则，如果s.getValue（）等于（“中止”）{
返回5；
}否则{
返回Integer.MAX_值；
}
}
公共整数比较（最终状态s1，最终状态s3）
{
返回getRank（s1）-getRank（S2）；
}
}

您可以为

状态

类创建自定义比较器，如下所示：

public final class StateComparator implements Comparator<State>
{

    private int getRank(final State s)
    {
        if (s.getValue().equals("Running"))
        {
            return 1;
        } else if (s.getValue().equals("Waiting")) {
            return 2;
        } else if (s.getValue().equals("Registering")) {
            return 3;
        } else if (s.getValue().equals("Completed")) {
            return 4;
        } else if s.getValue().equals("Aborted") {
            return 5;
        } else {
            return Integer.MAX_VALUE;
        }

    }

    public int compare(final State s1, final State s3)
    {
        return getRank(s1) - getRank(S2);
    }

}

public final类stateparator实现Comparator
{
私有int getRank（最终状态s）
{
如果（s.getValue（）.equals（“Running”））
{
返回1；
}如果（s.getValue（）.equals（“Waiting”））{
返回2；
}如果（s.getValue（）.equals（“注册”））{
返回3；
}否则如果（s.getValue（）.equals（“已完成”））{
返回4；
}否则，如果s.getValue（）等于（“中止”）{
返回5；
}否则{
返回Integer.MAX_值；
}
}
公共整数比较（最终状态s1，最终状态s3）
{
返回getRank（s1）-getRank（S2）；
}
}

您可以创建类似

public enum State {
    RUNNING, WAITING, REGISTERING, COMPLETED, ABORTED
}

默认情况下，这些状态将获得一个序数整数，该整数将根据您在枚举中写入它们的顺序。然后将此

状态

用作对象和创建比较器中的

状态

Comparator<MyClass> comparator = Comparator.comparing(MyClass::getState)
    .thenComparing(MyClass::getTimeStamp);

Comparator Comparator=Comparator.comparating（MyClass:：getState）
.Then比较（MyClass:：getTimeStamp）；

---

然后您可以使用comparator对集合进行排序

您可以创建一个类似

public enum State {
    RUNNING, WAITING, REGISTERING, COMPLETED, ABORTED
}

默认情况下，这些状态将获得一个序数整数，该整数将根据您在枚举中写入它们的顺序。然后将此

状态

用作对象和创建比较器中的

状态

Comparator<MyClass> comparator = Comparator.comparing(MyClass::getState)
    .thenComparing(MyClass::getTimeStamp);

Comparator Comparator=Comparator.comparating（MyClass:：getState）
.Then比较（MyClass:：getTimeStamp）；

---

然后，您可以使用比较器对集合进行排序

只需检查

state1.compareTo（state2）

是否返回0，这意味着两个状态相等，然后比较相等状态的时间戳或返回不相等状态的状态比较结果。您已经提到了

comparator

，您当前的状态是什么？但是如果state1.compareTo（state2）没有返回0，该怎么办？我认为您可能会遇到根据状态排序记录的问题，即哪些记录应该排在第一位，哪些记录应该排在第二位，等等。您可以将您的状态声明为枚举，并尝试根据您的顺序赋予它们序号，然后在比较器中使用序号而不是状态名称。将状态按您希望的顺序放入枚举中，因为枚举已经实现了Comparable。按状态然后按时间对对象排序必须检查

state1。compareTo（state2）

返回0，表示两个状态相等，然后比较相等状态的时间戳或返回不相等状态的状态比较结果。您已经提到了

Comparator

，您当前的状态是什么？但是如果state1.compareTo（state2）没有返回0，该怎么办？我认为您可能会遇到根据状态排序记录的问题，即哪些记录应该排在第一位，哪些记录应该排在第二位，等等。您可以将您的状态声明为枚举，并尝试根据您的顺序给它们序号，然后使用序号而不是状态