Java 从比较器到比较器的转换？

我通常有一个

比较器

类型，而我需要一个

可比较的

，反之亦然。是否有可重用的JDK API可以相互转换？大致如下：

    public static <C> Comparable<C> toComparable(final Comparator<C> comparator) {
        // does not compile because Hidden can not extend C, 
        // but just to illustrate the idea
        final class Hidden extends C implements Comparable<C> {
            @Override
            public int compareTo(C another) {
                return comparator.compare((C) this, another);
            }
        };
        return new Hidden();
    }

    public static <C extends Comparable<C>> Comparator<C> toComparator(final Class<C> comparableClass) {
        return new Comparator<C>() {
            @Override
            public int compare(C first, C second) {
                assert comparableClass.equals(first.getClass());
                assert comparableClass.equals(second.getClass());
                return first.compareTo(second);
            }
        };
    }

public static Comparable to Comparable（最终比较器）{
//未编译，因为Hidden无法扩展C，
//但只是为了说明这个想法
最后一个隐藏的类扩展了C实现{
@凌驾
公共整数比较（C另一个）{
返回比较器。比较（（C）这个，另一个）；
}
};
返回新的隐藏（）；
}
公共静态比较器与比较器（最终类可比类）{
返回新的比较器（）{
@凌驾
公共整数比较（C第一，C第二）{
断言comparableClass.equals（first.getClass（））；
断言comparableClass.equals（second.getClass（））；
首先返回。比较（第二）；
}
};
}
apachecommons集合中的
似乎解决了
Comparable
到
Comparator
的问题（不幸的是，它不支持泛型类型）

反向操作不太可能，因为
比较器
表示算法，而
Comparable
表示实际数据。你需要某种构图。快速而肮脏的解决方案：

class ComparableFromComparator<T> implements Comparable<T> {

    private final Comparator<T> comparator;
    private final T instance;

    public ComparableFromComparator(Comparator<T> comparator, T instance) {
        this.comparator = comparator;
        this.instance = instance;
    }

    @Override
    public int compareTo(T o) {
        return comparator.compare(instance, o);
    }

    public T getInstance() {
        return instance;
    }
}

正如您所看到的（尤其是没有mixin），它非常难看（我甚至不确定它是否能工作……）还要注意，
comparable
并没有扩展
Foo
，您必须调用
.getInstance（）
。
我认为您不能在它们之间真正转换，也没有意义，因为
comparable
是类本身的属性，而
Comparator
是外部类

最好的办法是编写某种实用程序类，其中包含底层比较逻辑（并且可能实现了
Comparator
），然后将该类用作类本身上的
可比
实现的逻辑的一部分。
可比项可以排序，因为它们具有
可比性：

Collection<Comparable> items;
Collections.sort(items);

开销太大。
自Java 8以来，该接口添加了一些实用默认方法，有助于从可比函数中导出比较器

考虑以下按名字对用户进行排序的示例

class Person {
    String firstName;
    String lastName;
}

List<Person> people = ...
people.sort(Comparator.comparing(Person::firstName));

班级人员{
字符串名；
字符串lastName；
}
列出人=。。。
排序（Comparator.comparing（Person:：firstName））；
不正确，
toComparator
有效，而另一个
toComparable
则是棘手的问题。对于大多数Java JDK，您都是对的，但有一些专有库需要这样或那样的代码，然后开发人员会到处编写转换样板代码。对于泛型友好的实现，番石榴的作品，并有很多额外的功能。
Collections<T> items;
Collections.sort(items, comparator);

public class CatorComparable<T> implements Comparable<CatorComparable<T>> {
    public T value;
    private Comparator<T> cator;

    public CatorComparable(T value, Comparator<T> cator) {
        this.value = value;
        this.cator = cator;
    }

    @Override
    public int compareTo(CatorComparable<T> other) {
        return cator.compareTo(value, other.value);
    }
}

class Person {
    String firstName;
    String lastName;
}

List<Person> people = ...
people.sort(Comparator.comparing(Person::firstName));