java - 比较按升序和降序排列使用 2 个属性

Question

我有一个具有多个属性的对象，用户可以选择其中两个属性进行排序，两者都可以是升序、降序或两者都不是(正常)，并且它们彼此独立。所以我的情况是:

案例一

• propA - 正常
• propB - 正常

案例二

• propA - 升序
• propB - 正常

案例三

• 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
            }
    }
}

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

Answer 1

我对您的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;
    }
}

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