java - 比较使用2个属性的升序和降序

我有一个具有多个属性的对象，用户可以选择其中的两个属性，二者都可以是升序，降序或两者都不是（“正常”），并且它们彼此独立。所以我的情况是：

情况1


propA-正常
propB-正常


情况二


propA-Asc
propB-正常


情况3


propA-描述
propB-正常


这样您就知道了。我正在使用Comparator进行此操作，到目前为止，当一个或两个值都设置为Normal时，我已经能够对其进行排序。我不确定的部分是选择两种方法进行排序时的处理方式。例如，如果我想按propA升序和propB降序排序，它应该看起来像这样

propA    propB
  A        Z
  A        D
  B        M
  B        A
  R        Q
  Z        Z
  Z        A

这是我现在的排序方式

@Override
public int compare(Field lhs, Field rhs) {
    switch (growerSort) {
        case NORMAL:
            switch (fieldSort) {
                case NORMAL:
                    return ((Integer) lhs.getID()).compareTo(rhs.getID());
                case ASC:
                    return lhs.getPropB().toLowerCase().compareTo(rhs.getPropB().toLowerCase());
                default:
                    return rhs.getPropB().toLowerCase().compareTo(lhs.getPropB().toLowerCase());
            }
        case ASC:
            switch (fieldSort) {
                case NORMAL:
                    return lhs.getPropA().toLowerCase().compareTo(rhs.getPropA().toLowerCase());;
                case ASC:
                    return 0; // 0 used as placeholder
                default:
                    return 0; // 0 used as placeholder
            }
        default:
            switch (fieldSort) {
                case NORMAL:
                    return rhs.getPropA().toLowerCase().compareTo(lhs.getPropA().toLowerCase());
                case ASC:
                    return 0; // 0 used as placeholder
                default:
                    return 0; // 0 used as placeholder
            }
    }
}

如何对两个不同的字段进行排序，每个字段都有各自的排序顺序？

最佳答案

我对您的Comparator感到有些困惑。要了解什么开关会触发什么事件并不容易。
但是，我将描述标准过程。

您需要对要比较的字段进行优先排序。在上面的示例中，我假设必须首先按propA，然后按propB对其进行排序。
然后，您首先按propA排序。如果返回“等于”（零），则要按下一个字段propB进行排序，依此类推。

让我给你看一个例子：

@Override
public int compare(final Field lhs, final Field rhs) {
    int firstCompareValue = lhs.getPropA().compareTo(rhs.getPropA());

    if (firstCompareValue == 0) {
        // lhs and rhs are equals in propA, use propB
        int secondCompareValue = lhs.getPropB().compareTo(rhs.getPropB());
        return secondCompareValue;
    } else {
        return firstCompareValue;
    }
}

当然，如果您有多个字段，也可以进行此迭代，只要您指定了顺序即可（例如，通过在属性字段上使用有序列表）。

现在，您需要将开关添加到此展示柜中：）我建议为此做一个PropertyComparator。

public final class PropertyComparator extends Comparator<Comparable<?>> {
    private final boolean mUseDscOrder = false;

    public void setUseDscOrder(final boolean useDscOrder) {
            mUseDscOrder = useDscOrder;
    }

    public int compare(final Comparable<?> o1, final Comparable<?> o2) {
            if (!mUseDscOrder) {
                    return o1.compareTo(o2);
            } else {
                    // Reverses the logic, results in DscOrder
                    return o2.compareTo(o1)
            }
    }
}

现在在上面的Comparator中使用它。

@Override
public int compare(final Field lhs, final Field rhs, final boolean firstUseDscOrder, final boolean secondUseDcsOrder) {
    PropertyComparator firstComparator = new PropertyComparator();
    firstComparator.setUseDscOrder(firstUseDscOrder);

    int firstCompareValue = firstComparator.compare(lhs.getPropA(), rhs.getPropA());

    if (firstCompareValue == 0) {
        // lhs and rhs are equals in propA, use propB

        PropertyComparator secondComparator = new PropertyComparator();
        secondComparator.setUseDscOrder(secondUseDscOrder);

        int secondCompareValue = secondComparator.compare(lhs.getPropB(), rhs.getPropB());
        return secondCompareValue;
    } else {
        return firstCompareValue;
    }
}

我没有测试过，但是我想你明白了:)