当提供自定义比较器或元素实现可比较时，在方法中拆分逻辑？

Question

在方法中拆分逻辑的最佳实践是什么，谁将使用可比较的元素，或者在创建时提供特定的比较器，取决于所使用的类的构造函数？示例：

public class MinMax<E> {

private final Comparator<? super E> comparator;
private final boolean isSpecificComparatorProvided;

public MinMax() {
    this.comparator = null;
    this.isSpecificComparatorProvided = false;
    ........;
}

public MinMax(Comparator<? super E> comparator) {
    this.comparator = comparator;
    this.isSpecificComparatorProvided = true;
    ........;
}

private boolean isBigOrEqual(E e1, E e2) {
    if (isSpecificComparatorProvided) {
        Comparator<? super E> cpr = comparator;
        int cmpr = cpr.compare(e1, e2);
        return cmpr > -1;
    } else {
        @SuppressWarnings("unchecked")
        Comparable<? super E> e1Comparable = (Comparable<? super E>) e1;
        int cmprTo = e1Comparable.compareTo(e2);
        return cmprTo > -1;
    }
}

}

我是否一直检查方法isBigOrEqual()中是否有特定的比较器？此外，当没有提供特定的比较器时，是否需要将其转换为可比的？还有别的路吗？

Answer 1

处理这个问题的最简单方法可能是只为Comparator实现这种情况，然后当您没有传递一个Comparator时，编写一个只在Comparable上工作的。(在Java8中，这只是Comparator.naturalOrder()。)

new Comparator<T> {
  @Override public int compare(T a, T b) {
    return a.compareTo(b);
  }
};

TreeMap并不是出于性能原因而这么做的，但这样做更简单。

Answer 2

您可以将E限制为类似于public class MinMax<E extends Comparable<E>>，这样就不再需要强制转换了，因为E在编译时必须具有可比性：

public class MinMax<E extends Comparable<E>> {

    private final Comparator<? super E> comparator;

    private final boolean isSpecificComparatorProvided;

    public MinMax() {
        this.comparator = null;
        this.isSpecificComparatorProvided = false;
    }

    public MinMax(Comparator<? super E> comparator) {
        this.comparator = comparator;
        this.isSpecificComparatorProvided = true;
    }

    private boolean isBigOrEqual(E e1, E e2) {
        if (this.isSpecificComparatorProvided) {
            return this.comparator.compare(e1, e2) > -1;
        } else {
            return e1.compareTo(e2) > -1;
        }
    }
}

Answer 3

在我看来，您想要抽象一种比较E类型的两个对象的方法，并且有两个实现。一种使用特定的Comparator，而另一种则处理Comparable对象。因此，您可以将这两种行为分成不同的类(实现)。

让我们从抽象概念的接口开始：

interface AbstractComparer<E> {
    public boolean isBigOrEqual(E e1, E e2);
}

很抱歉这个名字没有灵感。

接下来，让我们实现处理类似对象的案例：

class ComparableComparer<E extends Comparable<E>> implements AbstractComparer<E> {

    @Override
    public boolean isBigOrEqual(E e1, E e2) {
        return e1.compareTo(e2) > -1;
    }

}

另一种情况的实现通过构造函数接收特定的比较器：

class ComparatorComparer<E> implements AbstractComparer<E> {

    private Comparator<E> comparator;

    public ComparatorComparer(Comparator<E> comparator) {
        this.comparator = comparator;
    }

    @Override
    public boolean isBigOrEqual(E e1, E e2) {
        return this.comparator.compare(e1, e2) > -1;
    }
}

现在，我们可以简化MinMax类，并且可以通过构造函数提供比较方法：

public class MinMax<E> {

    private final AbstractComparer<E> comparer;

    public MinMax(AbstractComparer<E> comparer) {
        this.comparer = comparer;
    }

    private boolean isBigOrEqual(E e1, E e2) {
        return comparer.isBigOrEqual(e1, e2);
    }
}