使用 Comparable 比较泛型变量

Question

对于我的 class 中的一个家庭作业，我们有一个 collection 的 class 标题对，我们需要根据关键。

如果键是字符串或整数，我可以应用它，但是我如何编写代码来比较我的项目，如下所示？

我 class 的教授解释了如何处理整数或字符串，但是当我的变量是通用的时，我完全不知所措。

下面是我的代码相关部分的副本。

import java.util.*;


public class Utils {

    public static<K extends Comparable<K>, V> Collection<Pair<K,V>> sortPairCollection(Collection <Pair<K,V>> col){
        ArrayList <Pair<K,V>> list = new ArrayList<>();
        //Code to compare

        return list;
    }

    public static void main(String[] args) {
        ArrayList <Pair<String,Integer>> list = new ArrayList<>();
        Pair<String, Integer> e = new Pair<>("One", 1);
        list.add(e);
        Pair<String, Integer> f = new Pair<>("Two", 2);
        list.add(f);

        Utils help = new Utils();
        help.sortPairCollection(list);
    }
}

这里的第二部分是我的 Pair class 的代码。导入 java.io.Serializable；导入 java.util.Objects;

public class Pair <K,V> extends Object implements Serializable, Cloneable{


    public Pair(K k, V v){
       this.k = k;
       this.v = v;
    }


    public K k(){
       return k;
    }


    public V v(){
       return v;
    }


   /*
   ... //irrelevant data omitted
   */

   private final K k;
   private final V v;
}

Answer 1

选项1.Use一个比较器

public class Cmp<K extends Comparable<K>, V> implements Comparator<Pair<K, V>> {
   @Override
   public int compare(Pair<K, V> o1, Pair<K, V> o2) {
      return o1.k.compareTo(o2.k);
   }
}

public class Utils {
    public static <K extends Comparable<K>, V> Collection<Pair<K, V>> sortPairCollection(
            Collection<Pair<K, V>> col) {
        ArrayList<Pair<K, V>> list = new ArrayList<>();
        Collections.sort(list, new Cmp<>());
        return list;
    }
}

选项 2。实施比较

public class Pair<K extends Comparable<K>, V> implements Comparable<Pair<K, V>> {
    private K k;
    private V v;
    @Override
    public int compareTo(Pair<K, V> o) {
        return k.compareTo(o.k);
    }
}
public class Utils {
    public static <K extends Comparable<K>, V> Collection<Pair<K, V>> sortPairCollection(Collection<Pair<K, V>> col) {
        ArrayList<Pair<K, V>> list = new ArrayList<>();
        Collections.sort(list);
        return list;
    }
}

或者只是

public class Utils {
    public static <K extends Comparable<K>, V> Collection<Pair<K, V>> sortPairCollection(Collection<Pair<K, V>> col) {
        ArrayList<Pair<K, V>> list = new ArrayList<>();
        Collections.sort(list, (p, o) -> p.k.compareTo(o.k));
        return list;
    }
}

顺便说一句，您不必为静态方法创建实例。只需调用

Utils.sortPairCollection(list);

Answer 2

import java.util.*;
public class Utils {

public static <K extends Comparable<K>, V> Collection<Pair<K, V>> sortPairCollection(Collection<Pair<K, V>> col) {
    ArrayList<Pair<K, V>> list = new ArrayList<>(col);
    //Code to compare
    list.sort(Comparator.comparing(Pair::k)); //this is the only change needed
    return list;
}

public static void main(String[] args) {
    List<Pair<String, Integer>> listas = Arrays.asList(
        new Pair<>("One", 1),
        new Pair<>("Two", 2));
    System.out.println(Utils.sortPairCollection(listas));

}

我们在这里所做的是，我们从 Pair 中提取了一个已经 Camparable 的密钥，并将其传递给 Comparator class 静态方法，该方法将生成自定义Comparator 为我们 Pair class。请参阅 Comaparator here

的 Javadoc

Answer 3

如果你像我一样是一个干净优雅的代码爱好者，那么你可以使用 lambda 表达式的强大功能，当场创建一个匿名函数（没有名字的函数）来处理比较逻辑。从技术上讲，它与使用 Comparable 或 Comparator 函数式接口时相同，但使用 lambda 时，您不必通过仅为一个函数创建类来编写样板代码。相反，您以 lambda 表达式的形式当场创建该函数，java 处理其余部分。 Lambda 表达式是在 Java 8.

中引入的

Lambda 表达式的形式为 ( <parameters> ) -> { //body of the function }

public class Pair<K ,V extends Comparable<V>> {
private K k;
private V v;
public Pair(K k, V v){
   this.k = k;
   this.v = v;
}
public K k(){
   return k;
}
public V v(){
   return v;
}
}


public static void main(String[] args) {

        ArrayList <Pair<String,Integer>> list = new ArrayList<>();
        Pair<String, Integer> e = new Pair<>("One", 1);
        list.add(e);
        Pair<String, Integer> f = new Pair<>("Two", 2);
        list.add(f);

        // Second argument to this sort function is a lambda expression
        Collections.sort( list , (pair1 , pair2)->{

            return pair1.v().compareTo(pair2.v());

        });
    }
}

pair1 和 pair2 的数据类型将为 Pair 这里有一些关于 lambda 表达式和功能接口的入门链接

函数接口：https://www.geeksforgeeks.org/functional-interfaces-java/

Lambda 表达式：https://www.geeksforgeeks.org/lambda-expressions-java-8/

使用 Comparable 比较泛型变量

Using Comparable to compare generic variables

java

generics

comparable