20

我有一个具有两个类型变量的通用类，它实现了 java.lang.Comparable。

公共类 DoubleKey<K,J> 实现 Comparable<DoubleKey<K,J>>{

    私人 K 密钥 1；
    私人 J 密钥 2；

    公共双键（K key1，J key2）{
        这个.key1 = key1;
        this.key2 = key2;
    }

    公共 K getFirstKey(){
        返回 this.key1;
    }

    公共 J getSecondKey(){
        返回 this.key2;
    }

    // 需要 Comparable 接口
    public int compareTo(DoubleKey<K,J> aThat){
        ...
    }

}

因为我用 Comparable 实现了它，所以我需要编写 compareTo() 方法。因为 K, J 可以是任何类型，所以我在如何完全比较它们时遇到了问题。有没有办法在比较中捕获所有可能的类型（原始、包装、对象）？谢谢您的帮助！

4

6 回答 6

13

因此，总结上述内容并将其拼凑成一个工作代码，这是： 

    public class DoubleKey<K extends Comparable<K>, J extends Comparable<J>>
        implements Comparable<DoubleKey<K, J>> {

    private K key1;
    private J key2;

    public DoubleKey(K key1, J key2) {
        this.key1 = key1;
        this.key2 = key2;
    }

    public K getFirstKey() {
        return this.key1;
    }

    public J getSecondKey() {
        return this.key2;
    }

    public int compareTo(DoubleKey<K, J> that) {

        int cmp = this.getFirstKey().compareTo(that.getFirstKey());
        if (cmp == 0)
            cmp = this.getSecondKey().compareTo(that.getSecondKey());
        return cmp;
    }
}
于 2013-07-04T08:28:35.123 回答
8

您想介绍一个要求K并J具有可以使用的自然顺序吗？在这种情况下，您可以像这样声明您的类DoubleKey：

class DoubleKey<K extends Comparable<K>, J extends Comparable<J>>

然后，您可以根据需要定义您的 DoubleKey compareTo。您可以执行以下操作：

getFirstKey().compareTo(aThat.getFirstKey())

但是，您不能将 的任何实例与K的实例进行比较J。这些类型没有定义排序。

如果这些类型不一定具有自然顺序（很多没有），您可以将Comparator<K>andComparator<J>作为参数传递给DoubleKey. Google Guava 的优秀Maps类已经做到了这一点，您可以将其用作示例（具体请参见newTreeMap它们接受的类型的方法和边界）。

于 2011-02-16T08:16:50.263 回答
4 
公共类双键<
        K 实现 Comparable<K>，
        J 实现 Comparable<J>>
    实现 Comparable<DoubleKey<K,J>> {

    public int compareTo(DoubleKey<K,J> that){
        int cmp = this.key1.compareTo(that.key1);
        if(cmp==0) cmp = this.key2.compareTo(that.key2);
        返回cmp；
    }
}
于 2011-02-16T08:16:18.467 回答
0

当aDoubleKey<K,J>小于、大于或等于这个规则时，您必须定义一个规则。这就是比较的作用。也许，这是我的实际猜测，与DoubleKey<K,J>.

如果您实际上并不关心它们的排序方式，而只需要实现任何排序，请尝试以下操作：

public int compareTo(DoubleKey<K,J> that){
    // real codes needs checks for null values!
    return (this.key1.toString() + this.key2.toString()).compareTo(that.key1.toString() + that.key2.toString());
}
于 2011-02-16T08:15:22.790 回答
0

第一种方式：使用 hashCodes，比如

 public int compareTo(DoubleKey<K,J> aThat){
     getFirstKey().hashCode() + getSecondKey().hashCode() - aThat.getFirstKey().hashCode() +   aThat.getSecondKey().hashCode();
 }

（你应该更多地考虑公式）

第二种方式：将比较器添加到构造函数

public DoubleKey(K key1, J key2, Comparator cmp){
于 2011-02-16T08:16:18.190 回答
0

通常情况下，有一个库可以解决您的问题：Apache Commons lang3。我经常使用Pair<L,R>实例作为键。他们实现了 Comparable。

于 2013-08-13T07:30:58.457 回答