可选< T>的比较器

本文介绍了可选< 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()pareTo(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()pareTo(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(absentFirstIntpare(Optional.of(1), Optional.empty())); OptionalComparator<Integer> absentLastInt = absentLastComparator(); System.out.println(absentLastIntpare(Optional.of(1), Optional.empty())); OptionalComparator<Double> absentFirstDouble = absentFirstComparator(); System.out.println(absentFirstDoublepare(Optional.of(1.0), Optional.empty())); OptionalComparator<Double> absentLastDouble = absentLastComparator(); System.out.println(absentLastDoublepare(Optional.of(1.0), Optional.empty())); }

输出:

-1 1 -1 1