java – 可选的比较器

发布时间：2020-12-15 04:45:35 所属栏目：Java 来源：网络整理

导读：我有抽象类OptionalComparator T extends Comparable T implements Comparator Optional T 到现在为止还挺好. 遵循Optional本身使用的模型,我认为最好有一个这个类的单个实例,并在必要时强制转换它(例如,到OptionalComparator Integer). 所以我做了私有静态f

我有抽象类OptionalComparator< T extends Comparable< T>> implements Comparator< Optional< T>>

到现在为止还挺好.

遵循Optional本身使用的模型,我认为最好有一个这个类的单个实例,并在必要时强制转换它(例如,到OptionalComparator< Integer>).

所以我做了私有静态final OptionalComparator<？ extends Comparable<？>> ABSENT_FIRST.

当我试图分配一个值时出现了麻烦.该类型应该是什么？

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

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

例如,new OptionalComparator< Integer>(){…}确实有效,但我想要最不具体的类型.

我究竟做错了什么？如何创建此类的基本案例实例？

解决方法

你可以有如下的OptionalComparator的多个实现：

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

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!