Java 简化Collections.sort在自定义类型上的实现

我需要对我当前处理的工作列表进行排序：

List<Job> jobs = new ArrayList<Job>();
Job job0 = new Job("a", 1, Arrays.asList("t0"));
Job job1 = new Job("a", 2, Arrays.asList("t0"));
jobs.add(job0);
jobs.add(job1);
Comparator<Job> comparator = new Comparator<Job>() {
  @Override
  public int compare(Job o1, Job o2) {
    if (o1.getOrder() > o2.getOrder()) {
      return 1;
    }
    return 0;
  }
};
Collections.sort(jobs, comparator);

List jobs=new ArrayList（）；
jobjob0=新作业（“a”，1，Arrays.asList（“t0”）；
Job job1=新作业（“a”，2，Arrays.asList（“t0”）；
jobs.add（job0）；
添加（job1）；
比较器比较器=新比较器（）{
@凌驾
公共整数比较（作业o1、作业o2）{
如果（o1.getOrder（）>o2.getOrder（））{
返回1；
}
返回0；
}
};
集合。排序（作业、比较器）；

其中：

public class Job {
  private String path;
  private List<String> targets;
  private final int order;
  public Job(String path, int order, List<String> targets) {
    this.path = path;
    this.order = order;
    this.targets = targets;
  }
 ...
  public int getOrder() {
    return order;
  }
}

公共类作业{
私有字符串路径；
私人名单目标；
私人最终int订单；
公共作业（字符串路径、整数顺序、列表目标）{
this.path=path；
这个。顺序=顺序；
这个目标=目标；
}
...
public int getOrder（）{
退货单；
}
}

我想简化一下。所以我试过：

public class Job implements Comparable<Integer> {
  private String path;
  private List<String> targets;
  private final int order;
  public Job(String path, int order, List<String> targets) {
    this.path = path;
    this.order = order;
    this.targets = targets;
  }
  public int compareTo(Integer o) {
    // TODO Auto-generated method stub
    return 0;
  }
}

公共类作业实现可比较的{
私有字符串路径；
私人名单目标；
私人最终int订单；
公共作业（字符串路径、整数顺序、列表目标）{
this.path=path；
这个。顺序=顺序；
这个目标=目标；
}
公共整数比较o（整数o）{
//TODO自动生成的方法存根
返回0；
}
}

及

List jobs=new ArrayList（）；
收集、分类（作业）；

但是你可以得到：

Bound mismatch: The generic method sort(List<T>) of type Collections is not applicable for the arguments (List<Job>). The inferred type Job is not a valid substitute for the bounded parameter <T extends Comparable<? super T>>

---

绑定不匹配：类型集合的泛型方法排序（列表）不适用于参数（列表）。推断类型作业不是有界参数的有效替代品您可以这样做：

public class Job implements Comparable<Job> { // a job is comparable to another job
  private String path;
  private List<String> targets;
  private final int order;
  public Job(String path, int order, List<String> targets) {
    this.path = path;
    this.order = order;
    this.targets = targets;
  }
  public int compareTo(Job j) {
    return this.order - j.order; // here you specify how you want your jobs sorted
  }
}

公共类作业实现可比较{//一个作业与另一个作业可比较
私有字符串路径；
私人名单目标；
私人最终int订单；
公共作业（字符串路径、整数顺序、列表目标）{
this.path=path；
这个。顺序=顺序；
这个目标=目标；
}
公共内部比较（工作j）{
返回this.order-j.order；//在这里指定作业的排序方式
}
}
您可以这样做：

public class Job implements Comparable<Job> { // a job is comparable to another job
  private String path;
  private List<String> targets;
  private final int order;
  public Job(String path, int order, List<String> targets) {
    this.path = path;
    this.order = order;
    this.targets = targets;
  }
  public int compareTo(Job j) {
    return this.order - j.order; // here you specify how you want your jobs sorted
  }
}

公共类作业实现可比较{//一个作业与另一个作业可比较
私有字符串路径；
私人名单目标；
私人最终int订单；
公共作业（字符串路径、整数顺序、列表目标）{
this.path=path；
这个。顺序=顺序；
这个目标=目标；
}
公共内部比较（工作j）{
返回this.order-j.order；//在这里指定作业的排序方式
}
}
您需要
作业
来实现
可比
（为什么要让它实现
可比
？）。这是一个要求
a.compareTo（b）=-b.compareTo（a）
必须在与返回+1相反的情况下返回-1，反之亦然。@PeterLawrey如果不返回，会发生什么？只是一个坏的排序顺序？@JanDvorak“tim sort”可以检测到发生了这种情况并抛出异常。当您得到未排序的内容时，它可能检测不到问题。您需要
作业
来实现
可比
（为什么要让它实现
可比
？）。要求
a.compareTo（b）=-b.compareTo（a）
在返回+1时必须返回-1，反之亦然。@PeterLawrey如果不返回，会发生什么？只是一个坏的排序顺序？@JanDvorak“tim sort”可以检测到发生了这种情况并抛出异常。如果您得到未排序的内容，它可能检测不到问题。这可能会出现整数溢出（正常，不太可能），您可以使用
integer.compare（）
。使用类似这样的内容更安全。顺序>那个。顺序？1：（这个。order@radai只需使用
Integer.compare（order，j.order）
（不需要
这个
限定符）就可以了you@fge说到int和一个名为
order
的变量，我不想麻烦，除非order可以得到极值。但这是一个有用的注释，所以+1。奇怪的是，我没有整数。compare（）这可能会出现整数溢出（好的，不太可能），您可以使用
integer.compare（）
来代替。使用类似这样的内容更安全。order>that.order？1:（这个。order@radai只需使用
Integer.compare（order，j.order）
（不需要
这个
限定符）哪一个可以这样做you@fge说到int和一个名为
order
的变量，我不想麻烦，除非order可以得到极值。但这是一个有用的注释，所以+1。奇怪的是，我没有整数。compare（）