基于多个参数的Java数组排序答案

【问题标题】：Java Array Sorting based on multiple parameters基于多个参数的Java数组排序
【发布时间】：2015-06-02 00:07:51
【问题描述】：

我有一个要按升序排序的数组。但是，我想参考布尔数组对它们进行排序。我想按升序对 true 的值进行排序，然后按升序对 false 的值进行排序。怎么去那里有点卡住了。

这是我目前拥有的：

Object[] arr = new Object[6];

arr[0] = new Object(2); 
arr[1] = new Object(5); 
arr[2] = new Object(3); 
arr[3] = new Object(1);
arr[4] = new Object(6);
arr[5] = new Object(4);

Available[] avalarr = new Available[6];

availarr[0] = new Available (true);
availarr[1] = new Available (false);
availarr[2] = new Available (false);
availarr[3] = new Available (true);
availarr[4] = new Available (true);
availarr[5] = new Available (false);

我需要的输出是：

1 2 6 3 4 5

【问题讨论】：

首先，将“newAvailable”和您的对象放在一个要比较的对象中，例如定义一个包含两者实例的新对象。然后，实现一个自定义比较器 (docs.oracle.com/javase/7/docs/api/index.html?java/util/…)。您的“比较”方法应始终首先检查新对象的布尔值——然后是整数值。最后，将 Arrays.sort 与新的单个数组和新的比较器一起使用。
...虽然我不确定您所说的“new Object(2);”是什么意思。我假设你有一个类，比如“Thing”，它采用整数构造函数：class Thing { public Thing(int value){ this.value = value; } }。对吗？
感谢您的回复，非常感谢。我会测试看看效果如何。是的，你在变量上是正确的
你有 2 个数组吗？还是 1 个数组，其中填充了一个具有两个属性（1 个整数和 1 个布尔值）的类？
目前我有 2 个数组。

标签： java arrays sorting

【解决方案1】：

代码：

import java.util.Arrays;

public class SelectiveSort {

    public static void main(String[] args) {

        Item [] items = new Item [6];
        items[0] = new Item(2, true);
        items[1] = new Item(5, false);
        items[2] = new Item(3, false);
        items[3] = new Item(1, true);
        items[4] = new Item(6, true);
        items[5] = new Item(4, false);

        System.out.println("Before Sorting:");
        // Removed enhanced for loop
        for(int i = 0; i < items.length; i++) {
            System.out.print(items[i].getIntValue() + " ");
        }

        // Sorting
        Arrays.sort(items);

        System.out.println("\n\nAfter Sorting:");
        // Removed enhanced for loop
        for(int i = 0; i < items.length; i++) {
            System.out.print(items[i].getIntValue() + " ");
        }
        System.out.println();
    }
}

class Item implements Comparable<Item> {

    private int _intValue;
    private boolean _boolValue;

    public Item(int intValue, boolean boolValue) {
        _intValue = intValue;
        _boolValue = boolValue;
    }

    public int getIntValue() { return _intValue; }

    public boolean getBoolValue() { return _boolValue; }

    @Override
    public int compareTo(Item otherItem) {

        // Using explicit comparison
        int boolComparison = (_boolValue == otherItem._boolValue) ? 0 :
            (_boolValue) ? 1 : -1;
        return (boolComparison != 0) ? -boolComparison :
            ( (_intValue == otherItem.getIntValue()) ? 0 :
                (_intValue > otherItem.getIntValue()) ? 1 : -1);
    }
}

输出：

排序前： 2 5 3 1 6 4

排序后： 1 2 6 3 4 5

说明：

这个想法是让你的“项目”实现Comparable，并根据所需的顺序覆盖compareTo(Item otherItem)函数。
完成后，您需要做的就是在您的 Item 数组上调用 Arrays.sort()。

第 2 版（无可比/比较器）：

public class SelectiveSort {

    public static void main(String[] args) {

        Item [] items = new Item [6];
        items[0] = new Item(2, true);
        items[1] = new Item(5, false);
        items[2] = new Item(3, false);
        items[3] = new Item(1, true);
        items[4] = new Item(6, true);
        items[5] = new Item(4, false);

        System.out.println("Before Sorting:");
        for(int i = 0; i < items.length; i++) {
            System.out.print(items[i].getIntValue() + " ");
        }

        // Sorting
        bubbleSort(items);

        System.out.println("\n\nAfter Sorting:");
        for(int i = 0; i < items.length; i++) {
            System.out.print(items[i].getIntValue() + " ");
        }
        System.out.println();
    }

    public static void bubbleSort(Item [] items) {
        int n = items.length;
        do {
            int newN = 0;
            for(int i = 1; i < n; i++) {
                if(compareTo(items[i-1], items[i]) == 1) {
                    Item temp = items[i-1];
                    items[i-1] = items[i];
                    items[i] = temp;

                    newN = i;
                }
            }
            n = newN;
        } while (n != 0);
    }

    public static int compareTo(Item item1, Item item2) {

        int boolComparison = (item1.getBoolValue() == item2.getBoolValue())
                ? 0 : (item1.getBoolValue()) ? 1 : -1;
        return (boolComparison != 0) ? -boolComparison :
            ( (item1.getIntValue() == item2.getIntValue()) ? 0 :
                (item1.getIntValue() > item2.getIntValue()) ? 1 : -1);
    }
}

【讨论】：

感谢您的帮助伙计们，我一般都明白了。正如我所说，我对这一切都很陌生。编译项目时出现错误。有任何想法吗？干杯语义错误：增强的 for 循环（也称为 foreach 循环）仅支持 `-source 1.5' 或更高版本。
更新了我的答案，将“增强的 for 循环”更改为“正常的 for 循环”。
干杯。一个错误解决了另一个错误出现了？？？。线程“main”java.lang.Error 中的异常：未解决的编译问题：方法 compare(boolean, boolean) 未定义 Boolean 类型的方法 compare(int, int) 未定义 Integer
这与您使用的 Java 版本有关。无论如何，更新的答案。更改在 compareTo 函数中。
感谢您的帮助，非常感谢。完美运行。由于我对这一切都相当陌生，您是否会推荐任何特定的文献或课程？再次感谢。

【解决方案2】：

（扩展我的评论：

你需要一个基本的“东西”：

class Thing {
   boolean newAvailable;
   int order;
   public Thing(boolean newAvailable, int order) {
      ...
   }
}

...和一个可比的...

class CompareThings implements Comparator<Thing> {
    ...
    int compare(Thing t1, Thing t2) {
        if (t1.newAvailable!=t2.newAvailable)
            return t1.newAvailable==true ? 1 : -1;
        return t1.order-t2.order;
    }
}

（请注意 t1.newAvailable==true 是多余的，但我认为它澄清了这里发生的事情。）

现在构建一个 Thing 数组并调用 Arrays.sort(Thing[] things, CompareThings);

【讨论】：