在Java中排序二维数组-跳过第一个索引

我在Java中有一个二维数组，如下所示：

每个元素/作业都有一个：

• 索引[0]中的作业编号
• 索引[1]中的作业到达时间；及
• 索引[2]中的作业突发时间

首先，我想根据到达时间对它们进行排序，这是根据索引[1]进行的，幸运的是，我使用了以下代码：

Arrays.sort(jobs, new Comparator<int[]>(){
    public int compare(int[] a, int[] b) {
        return a[1] - b[1];
    }
});

---

正在按突发时间对作业进行排序，作业1保持在顶部用我上面提供的代码实现它会更好。谢谢

一个简单的方法是：

int firstBurst = jobs[0][2];
jobs[0][2] = Integer.MIN_VALUE;
Arrays.sort(jobs, new Comparator<int[]>(){
    public int compare(int[] a, int[] b) {
        // don't use subtraction, this can lead to underflows
        return a[2] < b[2] ? -1 : (a[2] == b[2] ? 0 : 1);
    }
});
jobs[0][2] = firstBurst;

然后您可以直接执行此操作：

Arrays.sort(jobs, 1, jobs.length, new Comparator<int[]>(){
    public int compare(int[] a, int[] b) {
        // don't use subtraction, this can lead to underflows
        return a[2] < b[2] ? -1 : (a[2] == b[2] ? 0 : 1);
    }
});

Arrays.sort（jobs，1，jobs.length，new Comparator（）{
公共整数比较（整数[]a，整数[]b）{
//不要使用减法，这可能会导致下溢
返回a[2]

首先，您应该使用集合而不是数组。其次，如果可以使用对象，则不应使用数组：

public class Job {
    private int number;
    private int arrival;
    private int burst;

    // constructor and getters omitted for brevity.
}

然后，您可以有一个

列表

，而不是

int[][]

。只要看一下结构的类型，它就已经更清晰、更可读了。拥有命名属性（可能是不同类型的属性），并能够通过方法添加行为，这是OO的一部分。比

int[]

更具可读性、安全性和可维护性

好消息是列表比数组具有更多的特性。例如，您可以获取一个子列表，并对该子列表进行排序：

List<Job> jobsExceptFirstOne = allJobs.subList(1);
Collections.sort(jobsExceptFirstOne, new Comparator<Job>() {
    @Override
    public int compare(Job left, Job right) {
        return Integer.compare(left.getBurst(), right.getBurst());
    }
});

List jobsceptfirstone=allJobs.subList（1）；
Collections.sort（jobseceptfirstone，newcomparator（）{
@凌驾
公共整数比较（作业左、作业右）{
返回整数.compare（left.getBurst（），right.getBurst（））；
}
});

---

瞧。问题已解决。

也许有一种方法可以使用：

final Integer job1 = Integer.valueOf(jobs[0][0]);
final Integer job2 = Integer.valueOf(jobs[0][1]);

return job1.compareTo(job2);

---

我真的不知道（作业[0][0]）的值是否会比（作业[0][1]）的值大，我也不知道它们之间的区别，但它们之间肯定有区别，因此，您应该能够根据返回的数字是否比作业[0][0]、作业[1][0]的值大或小对它们进行排序，等等。

使用比较器taht记住第一个作业的作业编号，并将其视为检查突发时间之前的最小值

public class MyComparator implements Comparator<int[]> {

    private final int firstJob;

    public MyComparator(int firstJob) {
        this.firstJob = firstJob;
    }

    public int compare(int[] a, int[] b) {
        if (a[0] == b[0]) {
            return 0;
        }
        if (a[0] == firstJob) {
            return -1;
        }
        if (b[0] == firstJob) {
            return 1;
        }
        return Integer.compare(a[2], b[2]);
    }
}

公共类MyComparator实现Comparator{
私人最终工作；
公共MyComparator（int firstJob）{
this.firstJob=firstJob；
}
公共整数比较（整数[]a，整数[]b）{
如果（a[0]==b[0]）{
返回0；
}
if（a[0]==firstJob）{
返回-1；
}
if（b[0]==firstJob）{
返回1；
}
返回整数。比较（a[2]，b[2]）；
}
}

正如其他人所说，你应该使用更智能的集合而不是数组，如果你真的想使用当前的代码，你可以使用类似于：

final int[][] jobs = new int[][]{{1,0,5},{2,2,19},{3,4,10}};

 Arrays.sort(jobs, new Comparator<int[]>(){
    public int compare(int[] a, int[] b) {
        if(Arrays.equals(a, jobs[0]))
         return -1;
        else
         return a[2] - b[2];
    }
});

System.out.println(jobs[0][2]);
System.out.println(jobs[1][2]);
System.out.println(jobs[2][2]);

final int[][]jobs=新int[][{{1,0,5}，{2,2,19}，{3,4,10}；
排序（作业，新比较器（）{
公共整数比较（整数[]a，整数[]b）{
if（Arrays.equals（a，作业[0]））
返回-1；
其他的
返回a[2]-b[2]；
}
});
System.out.println（作业[0][2]）；
System.out.println（作业[1][2]）；
System.out.println（作业[2][2]）；

---

唯一的缺点是你的数组需要是

final

太多的粗体字会伤害眼睛。返回的字符应该是这样的

返回a[2]？先生，你的代码成功了！谢谢。你能简单解释一下你的代码吗？@bowmore是的，对吗？或者说我把它与
集合混淆了。sort
？它是一种稳定的排序方法，只是指出这种方法中存在一些逻辑耦合。它被排序包括作业[0]作业[0]将始终处于使用此，这不是我的目的吗？我很感激你的回答，先生，但不幸的是，我不知道如何使用列表，现在它的代码相当长，如果我将所有内容都转换为列表，它会有很大的变化：（然后学习如何使用它们。这是任何Java开发人员都必须知道的。坚持你现在的糟糕设计会让事情变得越来越糟。你最好尽快解决这个问题。希望我会的，先生，非常感谢先生。我希望有一天我会成为像你们这样的人。专业开发人员。非常感谢先生
final Integer job1 = Integer.valueOf(jobs[0][0]);
final Integer job2 = Integer.valueOf(jobs[0][1]);

return job1.compareTo(job2);

public class MyComparator implements Comparator<int[]> {

    private final int firstJob;

    public MyComparator(int firstJob) {
        this.firstJob = firstJob;
    }

    public int compare(int[] a, int[] b) {
        if (a[0] == b[0]) {
            return 0;
        }
        if (a[0] == firstJob) {
            return -1;
        }
        if (b[0] == firstJob) {
            return 1;
        }
        return Integer.compare(a[2], b[2]);
    }
}

final int[][] jobs = new int[][]{{1,0,5},{2,2,19},{3,4,10}};

 Arrays.sort(jobs, new Comparator<int[]>(){
    public int compare(int[] a, int[] b) {
        if(Arrays.equals(a, jobs[0]))
         return -1;
        else
         return a[2] - b[2];
    }
});

System.out.println(jobs[0][2]);
System.out.println(jobs[1][2]);
System.out.println(jobs[2][2]);