Java 如何为一对泛型实现快速排序方法？

所以我有一个类对，它存储两个变量：key和value。我还有一个MyArrayList类，它扩展了ArrayList，并包含一个快速排序方法，可以对插入的整数ArrayList进行排序。我的问题是如何使这种快速排序方法使用成对的值，而不是arraylist中的单个值。 配对类别：

class Pair<K extends Comparable<K>, V extends Comparable<V>> {
public K key;
public V value;

// Default Constructor
public Pair(){
}

// Parametrized Constructor
public Pair(K key, V value){
this.key = key;
this.value = value;
}

@Override
public String toString() {
return "Pair {" + this.key + ", " + this.value + "}";
}

// Setter Functions:
public void setKey(K key){
this.key = key;
}

public void setValue(V value){
this.value = value;
}

// Getter Functions:
public K getKey(){
return key;
}

public V getValue(){
return value;
}

}

类对{
公钥；
公共价值观；
//默认构造函数
公共对（）{
}
//参数化构造函数
公共对（K键，V值）{
this.key=key；
这个值=值；
}
@凌驾
公共字符串toString（）{
返回“Pair{”+this.key+，“+this.value+”}”；
}
//设置器功能：
公共无效设置密钥（K密钥）{
this.key=key；
}
公共无效设置值（V值）{
这个值=值；
}
//Getter函数：
公共K getKey（）{
返回键；
}
public V getValue（）{
返回值；
}
}

MyArrayList类：

public class MyArrayList<K extends Comparable<K>, V extends Comparable<V>> extends ArrayList<Pair<K,V>>{
     MyArrayList<Integer ,Integer> array = new MyArrayList<Integer,Integer>();

     public static void main(String[] args){
     MyArrayList<String,Integer> array = new MyArrayList<String,Integer>();
    
    }   
 
  public String String(){
      ArrayList<String> copy = (ArrayList<String>)array.clone();
      return copy.toString();
    }
    
  public ArrayList QuickSort(ArrayList<Integer> arr){
      
      if (arr.size()< 1) return arr;
      
    ArrayList<Integer> sorted = new ArrayList<Integer>();
    ArrayList<Integer> lesser = new ArrayList<Integer>();
    ArrayList<Integer> greater = new ArrayList<Integer>();
    
    Integer pivot = arr.get(arr.size()-1); 
    
    for (int i = 0; i < array.size()-1; i++)
    {
        if (arr.get(i) < pivot)
            lesser.add(arr.get(i));    
        else
            greater.add(arr.get(i));   
    }

    lesser = QuickSort(lesser);
    greater = QuickSort(greater);

    lesser.add(pivot);
    lesser.addAll(greater);
    sorted = lesser;

    return sorted;
      
    }
    
    
    
}

公共类MyArrayList扩展了ArrayList{
MyArrayList数组=新的MyArrayList（）；
公共静态void main（字符串[]args）{
MyArrayList数组=新的MyArrayList（）；
}   
公共字符串（）{
ArrayList copy=（ArrayList）array.clone（）；
返回copy.toString（）；
}
公共ArrayList快速排序（ArrayList arr）{
if（arr.size（）<1）返回arr；
ArrayList sorted=新的ArrayList（）；
ArrayList lesser=新的ArrayList（）；
ArrayList更大=新的ArrayList（）；
整数pivot=arr.get（arr.size（）-1）；
对于（int i=0；i

好吧，你只是有点不得不这么做；）。首先，您必须确定比较两个

对的含义。我选择比较他们的钥匙。这将是一个很容易的改变，以比较他们的价值观，而不是任何其他类型的比较，你想设计。一旦决定，您只需在
对
类中重写
compareTo
，即可实现该决定

您必须更改排序代码才能使用
对
而不是
整数
s。最实质性的变化实际上是使用
compareTo
方法，而不是标准运算符。我做了转换，只是为了好玩，在进行时做了一些其他清理工作：

import java.util.ArrayList;

class Pair<K extends Comparable<K>, V extends Comparable<V>> {
    public K key;
    public V value;

    // Parametrized Constructor
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public String toString() {
        return "Pair {" + this.key + ", " + this.value + "}";
    }

    // Setter Functions:
    public void setKey(K key) {
        this.key = key;
    }

    public void setValue(V value) {
        this.value = value;
    }

    // Getter Functions:
    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    public int compareTo(Pair<K, V> o) {
        return key.compareTo(o.getKey());
    }
}

class MyArrayList<K extends Comparable<K>, V extends Comparable<V>> extends ArrayList<Pair<K, V>> {

    private ArrayList<Pair<K, V>> quicksort(ArrayList<Pair<K, V>> arr) {

        if (arr.size() < 2) return arr;

        ArrayList<Pair<K, V>> lesser = new ArrayList<>();
        ArrayList<Pair<K, V>> greater = new ArrayList<>();

        Pair<K, V> pivot = arr.get(arr.size() - 1);

        for (int i = 0; i < arr.size() - 1; i++) {
            if (arr.get(i).compareTo(pivot) < 0)
                lesser.add(arr.get(i));
            else
                greater.add(arr.get(i));
        }

        lesser = quicksort(lesser);
        greater = quicksort(greater);

        lesser.add(pivot);
        lesser.addAll(greater);

        return lesser;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (Pair<K, V> p : this) {
            if (sb.length() > 1)
                sb.append(',');
            sb.append('{').append(p.key).append(':').append(p.value).append('}');
        }
        sb.append(']');
        return sb.toString();
    }


    public void quicksort() {
        ArrayList<Pair<K, V>> r = quicksort(this);
        for (int i = 0 ; i < r.size() ; i++)
            set(i, r.get(i));
    }
}

public class Test {

    public static void main(String[] args) {
        MyArrayList<Integer, String> pairs = new MyArrayList<>();
        pairs.add(new Pair<>(7, "foo"));
        pairs.add(new Pair<>(23, "blah"));
        pairs.add(new Pair<>(24, "xxx"));
        pairs.add(new Pair<>(14, "blech"));
        pairs.add(new Pair<>(3, "abc"));
        pairs.add(new Pair<>(-24, "wow"));

        System.out.println(pairs);
        pairs.quicksort();
        System.out.println(pairs);
    }
}

为什么要自己实现排序？您的列表项已经实现了Comparable，因此您可以在列表上调用.sort（）。那么您如何知道它只是比较arraylist中的键或值？for循环中的i不会同时通过这两个变量吗？也谢谢你
[{7:foo},{23:blah},{24:xxx},{14:blech},{3:abc},{-24:wow}]
[{-24:wow},{3:abc},{7:foo},{14:blech},{23:blah},{24:xxx}]