compareTo 对 int 数组进行排序的问题答案

【问题标题】：compareTo issue with sorting an int arraycompareTo 对 int 数组进行排序的问题
【发布时间】：2016-01-03 07:39:03
【问题描述】：

我有一个整数数组，需要按升序排序。我必须使用compareTo。

我有一个问题的数组排序。最大的数首先出现在数组中；其余的按升序排列。

司机：导入 java.util.Scanner;

public class Driver2 {

    public static void main(String[] args) {

        int prior,compareResult;
        String task;
        Task[] taskList = new Task[4];
        int [] taskListPrior = new int[4];
        Scanner scan = new Scanner(System.in);


        System.out.print("Enter priority (between 1 & 10) for breakfast: ");
        prior = scan.nextInt();
        task = "eatBreakfast";

        Task eatBreakfast = new Task(prior,task);
        System.out.println("Breakfast priority is: " + eatBreakfast.getPriority());
        taskList[0] = eatBreakfast;
        taskListPrior[0] = eatBreakfast.getPriority();

        System.out.print("Enter priority (between 1 & 10) for lunch: ");
        prior = scan.nextInt();
        task = "eatLunch";

        Task eatLunch = new Task(prior,task);
        System.out.println("Lunch priority is: " + eatLunch.getPriority());
        taskList[1] = eatLunch;
        taskListPrior[1] = eatLunch.getPriority();

        System.out.print("Enter priority (between 1 & 10) for dinner: ");
        prior = scan.nextInt();
        task = "eatDinner";

        Task eatDinner = new Task(prior,task);
        System.out.println("Dinner priority is: " + eatDinner.getPriority());
        taskList[2] = eatDinner;
        taskListPrior[2] = eatDinner.getPriority();

        System.out.print("Enter priority (between 1 & 10) for nap: ");
        prior = scan.nextInt();
        task = "haveNap";

        Task haveNap = new Task(prior,task);
        System.out.println("Nap priority is: " + haveNap.getPriority());
        taskList[3] = haveNap;
        taskListPrior[3] = haveNap.getPriority();

        System.out.println("--------------");

        System.out.println("Printing task names and priorities:");
        for(int p = 0 ; p < taskListPrior.length ; p++)
        {
            System.out.println(taskListPrior[p] + " - " + taskList[p]);
        }

        System.out.print("Enter new priority (between 1 & 10) for nap: ");
        prior = scan.nextInt();
        haveNap.setPriority(prior);
        System.out.println("New priority for nap is: " + haveNap.getPriority());
        taskList[3] = haveNap;
        taskListPrior[3] = haveNap.getPriority();
        System.out.println("--------------");

        System.out.println("Printing task names and priorities:");
        for(int p = 0 ; p < taskListPrior.length ; p++)
        {
            System.out.println(taskListPrior[p] + " - " + taskList[p]);
        }

        Task tempTask;
        int tempTaskPrior;
        for(int current = 0 ; current < taskList.length ; current++) 
        {
                for(int i = 1 ; i < (taskList.length) ; i++)
                {
                    compareResult = (taskList[current]).compareTo(taskList[i]);
                    if(compareResult == 1){
                        tempTask = (taskList[i]);
                        tempTaskPrior = (taskListPrior[i]);
                        taskList[i] = (taskList[current]);
                        taskListPrior[i] = (taskListPrior[current]);
                        taskList[current]  = tempTask;
                        taskListPrior[current] = tempTaskPrior;
                    }
                  }
        }

        System.out.println("Printing sorted list of task names and priorities:");
        for(int p = 0 ; p < taskListPrior.length ; p++)
        {
            System.out.println(taskListPrior[p] + " - " + taskList[p]);
        }

        }

}

任务类：公共类任务实现优先级，可比{ public int Priority,priorityQuery,priorityNum; 公共字符串任务，taskItem，fullTask；任务taskName;

    public Task(int priorityQuery, String taskQuery){
        task = taskQuery;
        if (priorityQuery >= minPriority && priorityQuery <= maxPriority)
            prior = priorityQuery;
        else
            System.out.println("Out of valid range, task will have no priority");
    }

    public void setPriority(int priority)
    {
        if (priority >= minPriority && priority <= maxPriority)
            prior = priority;
            else
            System.out.println("Out of valid range, task will have no priority");
    }

    public int getPriority()
    {
        return prior;
    }

    public String toString(){
        taskItem = task;

        return taskItem;
    }

    public Task getTaskName(){
        return taskName;
    }

    public int compareTo(Task compTask){
        if (this.getPriority() < compTask.getPriority())
            return 1;
        else if (this.getPriority() > compTask.getPriority())
            return -1;
        else 
            return 0;

    }

}

实际上有两个并行数组，用于compareTo 方法的一个只包含整数。

【问题讨论】：

myList 和myListPriority 的类型是什么？你也可以添加java标签
所以“comapreTo”只对整数列表起作用。您的代码显示 myList... 上正在使用 compareTo() 方法，这表明 Integer 对象数组（不是 int[ ] ）。然后你有 tempTask = myList[i];那么你是说 tempTask 也是 Integer 类型的吗？如果您发布一些实际运行的代码，您将更有可能获得答案。
另外......你的 if( result == 1 ) 逻辑没有这样做。您需要处理结果 == 0、结果 0。您是否编写了自己的 compareTo() 方法？或者您正在使用 Java 通过 Integer 类提供的那个？（假设您的描述是准确的，并且您实际上并没有做类似 task1.compareTo(task2) 之类的事情；您没有发布足够的代码让我知道实际发生了什么）。
我已按要求添加了完整代码...
2 个问题：（1）为什么要使用单独的优先级列表，因为 Task 类已经包含优先级？ (2) 为什么不使用静态数组方法： public static void sort(T[] a, Comparator super T> c) （使用外部比较器）或 sort(Object[] a) (带有内部比较器）？

标签： java sorting

【解决方案1】：

该排序例程有问题。您每次都从 1 开始内部循环，因此 current 可能大于 i。因此，它会（在某些情况下）将现有的项目交换到不合适的位置。

正确的答案是使用java.util.Arrays.sort()。

如果您对排序算法感兴趣，请编写一个独立的类并实现一个单元测试脚本，以确保它在嵌入您的代码之前能够正常工作。

【讨论】：

不幸的是，如最初所述，compareTo 是必需的。是的，这是一个任务。最终，目标是确定前两个“优先事项”。
@abok 排序将使用 compareTo。但是，如果这是一项任务，那么按照我的建议单独实施一些事情。

【解决方案2】：

正如我之前评论中提到的，您应该尝试使用Arrays.sort(Object[] array) 的解决方案：

public class Driver {

    public static void main(String[] args) {

        int prior, compareResult;
        String task;
        Task[] taskList = new Task[4];
        Scanner scan = new Scanner(System.in);

        System.out.print("Enter priority (between 1 & 10) for breakfast: ");
        prior = scan.nextInt();
        task = "eatBreakfast";

        Task eatBreakfast = new Task(prior, task);
        System.out.println("Breakfast priority is: " + eatBreakfast.getPriority());
        taskList[0] = eatBreakfast;

        System.out.print("Enter priority (between 1 & 10) for lunch: ");
        prior = scan.nextInt();
        task = "eatLunch";

        Task eatLunch = new Task(prior, task);
        System.out.println("Lunch priority is: " + eatLunch.getPriority());
        taskList[1] = eatLunch;

        System.out.print("Enter priority (between 1 & 10) for dinner: ");
        prior = scan.nextInt();
        task = "eatDinner";

        Task eatDinner = new Task(prior, task);
        System.out.println("Dinner priority is: " + eatDinner.getPriority());
        taskList[2] = eatDinner;

        System.out.print("Enter priority (between 1 & 10) for nap: ");
        prior = scan.nextInt();
        task = "haveNap";

        Task haveNap = new Task(prior, task);
        System.out.println("Nap priority is: " + haveNap.getPriority());
        taskList[3] = haveNap;

        System.out.println("--------------");

        System.out.println("Printing task names and priorities:");
        for (Task t : taskList) {
            System.out.println(t.prior + " - " + t.task);
        }

        System.out.print("Enter new priority (between 1 & 10) for nap: ");
        prior = scan.nextInt();
        haveNap.setPriority(prior);
        System.out.println("New priority for nap is: " + haveNap.getPriority());
        taskList[3] = haveNap;
        System.out.println("--------------");

        System.out.println("Printing task names and priorities:");
        for (Task t : taskList) {
            System.out.println(t.prior + " - " + t.task);
        }

        //  Sort this      
        Arrays.sort(taskList);

        System.out.println("Printing sorted list of task names and priorities:");
        for (Task t : taskList) {
            System.out.println(t.prior + " - " + t.task);
        }

    }

}

我删除了对int [] taskListPrior = new int[4]; 的所有引用，这是毫无意义的，并用简单的Arrays.sort(taskList) 替换了您的排序算法。

您的 Task 类可能保持不变，但您应该扩展它的 compareTo 方法，以解决两个比较任务的优先级相同的情况。我在任务字段上加了一个对比：

public int compareTo(Task compTask) {
    if (compTask==null) return 1;

    if (this.getPriority() < compTask.getPriority())
        return 1;
    else if (this.getPriority() > compTask.getPriority())
        return -1;
    else
        return this.task.compareTo(compTask.task);

}

【讨论】：

@Ivr123 - 我完全同意 Arrays.sort 是对列表进行排序的最佳方式。不幸的是，我需要实现 Comparable 接口并使用 compareTo 按优先级对列表进行排序。
@abok ：我不明白你在说什么。你更了解它。 Task 实现 Comparable 及其 compareTo 按优先级对列表进行排序。即使您想要列表的其他顺序，您也可以创建一个 Comparator 类来实现您真正想要的排序顺序。
@Ivr123 - 再次感谢您的帮助......在大多数情况下，我的排序工作正常，除了最大的数字首先出现。由于我需要使用 Task 实现的 compareTo 方法来进行排序，这是我必须尝试和理解的。