Java：访问向量的int值<；配对<；字符串，int>&燃气轮机；在索引i处

我创建了一个名为Pair的泛型集合类

public class Pair<L,R> {
private L l;
private R r;

public Pair(L l, R r){
    this.l = l;
    this.r = r;
}
public L getL(){
    return l;
}
public R getR(){
    return r;
}
public void setL(L l){
    this.l = l;
}
public void setR(R r){
    this.r = r;
}
}

公共类对{
私人L；
私人住宅；
公共对（左，右）{
这个。l=l；
这个。r=r；
}
公共L getL（）{
返回l；
}
公共R getR（）{
返回r；
}
公共无效集合（L）{
这个。l=l；
}
公共无效设置器（R）{
这个。r=r；
}
}

然后我想创建一个名为records的向量

Pair<String, int>

对

这样我可以在以后遍历向量并比较向量不同索引处的int值。 我是通过以下代码实现的：

private Vector<Pair<String, Long>> records = new Vector();

私有向量记录=新向量（）；

然后在排序函数中比较不同索引处的int值

public void sort(){
    int n = records.size();
    int p = 0;
    int i, j;

    for(p = 0; p < n-1; p++){
        j = p;
        for(i = p+1; i<n; i++){
            if(records.get(i) < records.get(j))
                j = i;
        }   
    }
}

public void sort（）{
int n=records.size（）；
int p=0；
int i，j；
对于（p=0；p对于（i=p+1；i尽管Java中没有重载运算符，但您不能使用
比较对象。您应该实现
Comparable
接口并使用其
compareTo（）
方法：

public class Pair<L, R> implements Comparable<Pair<L, R>> {
    private L l;
    private R r;

    // ... remaining part ...

    @Override
    public int compareTo(Pair p) {
         // e.g. comparison by length of `toString` representation
         return (toString().length() - p.toString().length());
    }

}

要通过一些有意义的值来比较
对
对象，您应该实现
compareTo（）
方法的更复杂逻辑——因为在设计时，您无法知道哪些类型是
L
和
R
，对于编译器来说，它们是没有特定类型的对象

要解决此问题，可以显式定义以下类型：

class Pair<L extends Comparable<L>, R extends Comparable<R>> implements Comparable<Pair<L, R>> {
    //...
} 

类对实现了可比较的{
//...
} 

并使用
L#compareTo（）
或/和
R#compareTo（）
方法实现
Pair#compareTo（）

String
和
Long
都实现了
compariable
，因此它们可以用作此类的类型

另一种方法是实现您的
Pair
类，该类不包含泛型int（long）值作为属性，就像
Pair
构造函数
Pair（tt，int-length）
给定记录的类型，那么
记录会得到什么呢和
Map.Entry
？
class Pair<L extends Comparable<L>, R extends Comparable<R>> implements Comparable<Pair<L, R>> {
    //...
}