Использование Comparable для сравнения общих переменных

Question

Для одного из домашних заданий в моем классе у нас есть коллекция класса с названием Pair, и нам нужно отсортировать ее в порядке возрастания на основе значения ключа.

Я мог бы применить это, если бы ключи были строками или целыми числами, но как мне написать код, который бы сравнивал мои элементы, когда они являются общими, как показано ниже?

Профессор в моем классе объяснил, что делать с целыми числами или строками, но когда мои переменные являются общими, я в полной растерянности.

Ниже приведены копии соответствующих частей моего кода.

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. импорт java.io.Serializable; import 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

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));

}

Что мы сделали здесь, так это то, что мы извлекли ключ Camparable из нашего Pair и передали его статическому методу класса Comparator, который сгенерирует пользовательский Comparator для нашего класса Pair,См. Javadoc для Comaparator здесь

Answer 2

Если вы любитель чистого и элегантного кода, как я, вы можете использовать мощь лямбда-выражения для создания анонимной функции (функции без имени) на месте, которая обрабатывает логику сравнения. Технически это то же самое, что и при использовании функциональных интерфейсов Comparable или Comparator, но используя лямбды-выражения, вам не нужно писать шаблонный код, создавая классы только для одной функции. Вместо этого вы создаете эту функцию на месте в форме лямбда-выражения, а java обрабатывает все остальное. Лямбда-выражения были введены в Java 8.

Лямбда-выражение имеет вид ( <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 будет пара Вот несколько начальных ссылок о лямбда-выражении и функциональных интерфейсах

Функциональные интерфейсы: https://www.geeksforgeeks.org/functional-interfaces-java/

Лямбда-выражения: https://www.geeksforgeeks.org/lambda-expressions-java-8/

Answer 3

Вариант 1. Используйте компаратор

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);