可选< T>的比较器 [英] Comparator for Optional<T>

问题描述

我有abstract class OptionalComparator<T extends Comparable<T>> implements Comparator<Optional<T>>

到目前为止，很好.

按照Optional本身使用的模型，我认为最好有一个此类的实例，并在必要时将其强制转换(例如，投射到OptionalComparator<Integer>).

Following the model used by Optional itself, I figured it would be best to have a single instance of this class, and cast it when necessary (for example, to OptionalComparator<Integer>).

所以我做了private static final OptionalComparator<? extends Comparable<?>> ABSENT_FIRST.

当我尝试分配一个值时，麻烦就来了.类型应该是什么?

The trouble came when I tried to assign a value. What should the type be?

new OptionalComparator<Comparable<Object>>() {...}不起作用.

new OptionalComparator<Comparable<Comparable<Object>>>() {...}不起作用.

new OptionalComparator<Integer>() {...}确实可以工作，但是我想要尽可能少的特定类型.

new OptionalComparator<Integer>() {...} does work, for example, but I want the least-specific type possible.

我做错了什么?如何制作此类的基本实例?

What am I doing wrong? How can I make a base-case instance of this class?

推荐答案

您可以具有OptionalComparator的多种实现，如下所示:

You can have multiple implementations of OptionalComparator like this:

private static final OptionalComparator<? extends Comparable<?>> ABSENT_FIRST = new AbsentFirst<>();

private static final OptionalComparator<? extends Comparable<?>> ABSENT_LAST = new AbsentLast<>();

private interface OptionalComparator<T extends Comparable<T>> extends Comparator<Optional<T>> { }

private static class AbsentFirst<T extends Comparable<T>> implements OptionalComparator<T> {
    @Override
    public int compare(Optional<T> obj1, Optional<T> obj2) {
        if (obj1.isPresent() && obj2.isPresent()) {
            return obj1.get().compareTo(obj2.get());
        } else if (obj1.isPresent()) {
            return -1;
        } else if (obj2.isPresent()) {
            return 1;
        } else {
            return 0;
        }
    }
}

private static class AbsentLast<T extends Comparable<T>> implements OptionalComparator<T> {
    @Override
    public int compare(Optional<T> obj1, Optional<T> obj2) {
        if (obj1.isPresent() && obj2.isPresent()) {
            return obj1.get().compareTo(obj2.get());
        } else if (obj1.isPresent()) {
            return 1;
        } else if (obj2.isPresent()) {
            return -1;
        } else {
            return 0;
        }
    }
}

static <T extends Comparable<T>> OptionalComparator<T> absentFirstComparator() {
    @SuppressWarnings("unchecked")
    OptionalComparator<T> comp = (OptionalComparator<T>) ABSENT_FIRST;
    return comp;
}

static <T extends Comparable<T>> OptionalComparator<T> absentLastComparator() {
    @SuppressWarnings("unchecked")
    OptionalComparator<T> comp = (OptionalComparator<T>) ABSENT_LAST;
    return comp;
}

public static void main(String... args) {
    OptionalComparator<Integer> absentFirstInt = absentFirstComparator();
    System.out.println(absentFirstInt.compare(Optional.of(1), Optional.empty()));

    OptionalComparator<Integer> absentLastInt = absentLastComparator();
    System.out.println(absentLastInt.compare(Optional.of(1), Optional.empty()));

    OptionalComparator<Double> absentFirstDouble = absentFirstComparator();
    System.out.println(absentFirstDouble.compare(Optional.of(1.0), Optional.empty()));

    OptionalComparator<Double> absentLastDouble = absentLastComparator();
    System.out.println(absentLastDouble.compare(Optional.of(1.0), Optional.empty()));
}

输出:

-1
1
-1
1

这篇关于可选< T>的比较器的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！